| Modifier and Type | Method and Description |
|---|---|
static Pair<INDArray,INDArray> |
TimeSeriesWritableUtils.convertWritablesSequence(List<List<List<Writable>>> timeSeriesRecord)
Convert the writables
to a sequence (3d) data set,
and also return the
mask array (if necessary)
|
static Pair<INDArray,INDArray> |
TimeSeriesWritableUtils.convertWritablesSequence(List<List<List<Writable>>> timeSeriesRecord)
Convert the writables
to a sequence (3d) data set,
and also return the
mask array (if necessary)
|
static Pair<INDArray,INDArray> |
TimeSeriesWritableUtils.convertWritablesSequence(List<List<List<Writable>>> list,
TimeSeriesWritableUtils.RecordDetails details)
Convert the writables
to a sequence (3d) data set,
and also return the
mask array (if necessary)
|
static Pair<INDArray,INDArray> |
TimeSeriesWritableUtils.convertWritablesSequence(List<List<List<Writable>>> list,
TimeSeriesWritableUtils.RecordDetails details)
Convert the writables
to a sequence (3d) data set,
and also return the
mask array (if necessary)
|
| Modifier and Type | Method and Description |
|---|---|
protected INDArray |
StringListToIndicesNDArrayTransform.makeBOWNDArray(Collection<Integer> indices) |
protected INDArray |
StringListToCountsNDArrayTransform.makeBOWNDArray(Collection<Integer> indices) |
| Modifier and Type | Method and Description |
|---|---|
static INDArray |
RecordConverter.toArray(Collection<? extends Writable> record)
Convert a record to an INDArray.
|
static INDArray |
RecordConverter.toArray(Collection<Writable> record,
int size)
Deprecated.
|
static INDArray |
RecordConverter.toMatrix(List<List<Writable>> records)
Convert a set of records in to a matrix
|
static INDArray |
RecordConverter.toMinibatchArray(List<? extends Writable> l)
Convert a record to an INDArray, for use in minibatch training.
|
static INDArray |
RecordConverter.toTensor(List<List<List<Writable>>> records)
Convert a set of records in to a matrix
|
| Modifier and Type | Method and Description |
|---|---|
static List<Writable> |
RecordConverter.toRecord(INDArray array)
Convert an ndarray to a record
|
static List<List<Writable>> |
RecordConverter.toRecords(INDArray matrix)
Convert a set of records in to a matrix
|
| Modifier and Type | Method and Description |
|---|---|
INDArray |
NDArrayWritable.get() |
| Modifier and Type | Method and Description |
|---|---|
void |
NDArrayWritable.set(INDArray array) |
| Constructor and Description |
|---|
NDArrayWritable(INDArray array) |
| Constructor and Description |
|---|
NDArrayRecordBatch(INDArray... arrays) |
| Constructor and Description |
|---|
NDArrayRecordBatch(List<INDArray> arrays) |
| Modifier and Type | Method and Description |
|---|---|
static INDArray |
ArrowConverter.convertArrowVector(org.apache.arrow.vector.FieldVector fieldVector,
ColumnType type)
Convert a field vector to a column vector
|
static INDArray |
ArrowConverter.toArray(ArrowWritableRecordBatch arrowWritableRecordBatch)
Create an ndarray from a matrix.
|
static INDArray |
ArrowConverter.toArray(ArrowWritableRecordTimeSeriesBatch arrowWritableRecordBatch)
Create an ndarray from a matrix.
|
| Modifier and Type | Method and Description |
|---|---|
static List<org.apache.arrow.vector.FieldVector> |
ArrowConverter.convertToArrowVector(INDArray from,
List<String> name,
ColumnType type,
org.apache.arrow.memory.BufferAllocator bufferAllocator)
Convert an
INDArray
to a list of column vectors or a singleton
list when either a row vector or a column vector |
static org.apache.arrow.vector.VarBinaryVector |
ArrowConverter.vectorFor(org.apache.arrow.memory.BufferAllocator bufferAllocator,
String name,
INDArray[] data)
Returns a vector representing a tensor view
of each ndarray.
|
| Modifier and Type | Method and Description |
|---|---|
INDArray |
ImageLoader.asImageMiniBatches(File f,
int numMiniBatches,
int numRowsPerSlice)
Slices up an image in to a mini batch.
|
INDArray |
AndroidNativeImageLoader.asMatrix(android.graphics.Bitmap image) |
INDArray |
Java2DNativeImageLoader.asMatrix(BufferedImage image)
Returns
asMatrix(image, false). |
INDArray |
ImageLoader.asMatrix(BufferedImage image)
Convert an BufferedImage to a matrix
|
INDArray |
Java2DNativeImageLoader.asMatrix(BufferedImage image,
boolean flipChannels)
Loads a
INDArray from a BufferedImage. |
INDArray |
NativeImageLoader.asMatrix(File f) |
INDArray |
LFWLoader.asMatrix(File f) |
INDArray |
ImageLoader.asMatrix(File f)
Convert an image file
in to a matrix
|
INDArray |
CifarLoader.asMatrix(File f) |
abstract INDArray |
BaseImageLoader.asMatrix(File f) |
INDArray |
NativeImageLoader.asMatrix(org.bytedeco.javacv.Frame image) |
INDArray |
NativeImageLoader.asMatrix(ImageWritable writable)
Convert ImageWritable to INDArray
|
INDArray |
NativeImageLoader.asMatrix(InputStream is) |
INDArray |
LFWLoader.asMatrix(InputStream inputStream) |
INDArray |
ImageLoader.asMatrix(InputStream inputStream)
Convert an input stream to a matrix
|
INDArray |
CifarLoader.asMatrix(InputStream inputStream) |
abstract INDArray |
BaseImageLoader.asMatrix(InputStream inputStream) |
INDArray |
NativeImageLoader.asMatrix(org.opencv.core.Mat image) |
INDArray |
NativeImageLoader.asMatrix(org.bytedeco.opencv.opencv_core.Mat image) |
INDArray |
NativeImageLoader.asMatrix(Object image)
|
INDArray |
Java2DNativeImageLoader.asMatrix(Object image) |
INDArray |
AndroidNativeImageLoader.asMatrix(Object image) |
INDArray |
NativeImageLoader.asMatrix(String filename) |
INDArray |
AndroidNativeImageLoader.asRowVector(android.graphics.Bitmap image) |
INDArray |
Java2DNativeImageLoader.asRowVector(BufferedImage image)
Returns
asMatrix(image, false).ravel(). |
INDArray |
ImageLoader.asRowVector(BufferedImage image)
Convert an image in to a row vector
|
INDArray |
Java2DNativeImageLoader.asRowVector(BufferedImage image,
boolean flipChannels)
Returns
asMatrix(image, flipChannels).ravel(). |
INDArray |
NativeImageLoader.asRowVector(File f)
Convert a file to a row vector
|
INDArray |
LFWLoader.asRowVector(File f) |
INDArray |
ImageLoader.asRowVector(File f)
Convert a file to a row vector
|
INDArray |
CifarLoader.asRowVector(File f) |
abstract INDArray |
BaseImageLoader.asRowVector(File f) |
INDArray |
NativeImageLoader.asRowVector(org.bytedeco.javacv.Frame image) |
INDArray |
NativeImageLoader.asRowVector(InputStream is) |
INDArray |
LFWLoader.asRowVector(InputStream inputStream) |
INDArray |
ImageLoader.asRowVector(InputStream inputStream) |
INDArray |
CifarLoader.asRowVector(InputStream inputStream) |
abstract INDArray |
BaseImageLoader.asRowVector(InputStream inputStream) |
INDArray |
NativeImageLoader.asRowVector(org.bytedeco.opencv.opencv_core.Mat image) |
INDArray |
NativeImageLoader.asRowVector(org.opencv.core.Mat image) |
INDArray |
NativeImageLoader.asRowVector(Object image)
Returns
asMatrix(image).ravel(). |
INDArray |
Java2DNativeImageLoader.asRowVector(Object image) |
INDArray |
AndroidNativeImageLoader.asRowVector(Object image) |
INDArray |
NativeImageLoader.asRowVector(String filename) |
INDArray |
ImageLoader.toBgr(BufferedImage image)
Convert an BufferedImage to an bgr spectrum image
|
INDArray |
ImageLoader.toBgr(File file)
Convert an input stream to an bgr spectrum image
|
INDArray |
ImageLoader.toBgr(InputStream inputStream)
Convert an input stream to an bgr spectrum image
|
protected INDArray |
ImageLoader.toINDArrayBGR(BufferedImage image) |
INDArray |
ImageLoader.toRaveledTensor(BufferedImage image)
Convert an image in to a raveled tensor of
the bgr values of the image
|
INDArray |
ImageLoader.toRaveledTensor(File file)
Changes the input stream in to an
bgr based raveled(flattened) vector
|
INDArray |
ImageLoader.toRaveledTensor(InputStream is)
Changes the input stream in to an
bgr based raveled(flattened) vector
|
protected INDArray |
NativeImageLoader.transformImage(org.opencv.core.Mat image,
INDArray ret) |
protected INDArray |
NativeImageLoader.transformImage(org.bytedeco.opencv.opencv_core.Mat image,
INDArray ret) |
| Modifier and Type | Method and Description |
|---|---|
Pair<INDArray,org.bytedeco.opencv.opencv_core.Mat> |
CifarLoader.convertMat(byte[] byteFeature) |
| Modifier and Type | Method and Description |
|---|---|
android.graphics.Bitmap |
AndroidNativeImageLoader.asBitmap(INDArray array)
Returns
asBitmap(array, Frame.DEPTH_UBYTE). |
android.graphics.Bitmap |
AndroidNativeImageLoader.asBitmap(INDArray array,
int dataType)
Converts an INDArray to a Bitmap.
|
BufferedImage |
Java2DNativeImageLoader.asBufferedImage(INDArray array)
Returns
asBufferedImage(array, Frame.DEPTH_UBYTE). |
BufferedImage |
Java2DNativeImageLoader.asBufferedImage(INDArray array,
int dataType)
Converts an INDArray to a BufferedImage.
|
org.bytedeco.javacv.Frame |
NativeImageLoader.asFrame(INDArray array)
Returns
asFrame(array, -1). |
org.bytedeco.javacv.Frame |
NativeImageLoader.asFrame(INDArray array,
int dataType)
Converts an INDArray to a JavaCV Frame.
|
org.bytedeco.opencv.opencv_core.Mat |
NativeImageLoader.asMat(INDArray array)
Returns
asMat(array, -1). |
org.bytedeco.opencv.opencv_core.Mat |
NativeImageLoader.asMat(INDArray array,
int dataType)
Converts an INDArray to an OpenCV Mat.
|
void |
NativeImageLoader.asMatrixView(File f,
INDArray view) |
void |
NativeImageLoader.asMatrixView(InputStream is,
INDArray view) |
void |
NativeImageLoader.asMatrixView(org.bytedeco.opencv.opencv_core.Mat image,
INDArray view) |
void |
NativeImageLoader.asMatrixView(org.opencv.core.Mat image,
INDArray view) |
void |
NativeImageLoader.asMatrixView(String filename,
INDArray view) |
protected void |
NativeImageLoader.fillNDArray(org.bytedeco.opencv.opencv_core.Mat image,
INDArray ret) |
void |
ImageLoader.toBufferedImageRGB(INDArray arr,
BufferedImage image)
Convert the given image to an rgb image
|
static BufferedImage |
ImageLoader.toImage(INDArray matrix)
Convert a matrix in to a buffereed image
|
protected INDArray |
NativeImageLoader.transformImage(org.opencv.core.Mat image,
INDArray ret) |
protected INDArray |
NativeImageLoader.transformImage(org.bytedeco.opencv.opencv_core.Mat image,
INDArray ret) |
double |
CifarLoader.varManual(INDArray x,
double mean) |
| Modifier and Type | Method and Description |
|---|---|
static void |
DrawMnist.drawMnist(DataSet mnist,
INDArray reconstruct) |
| Constructor and Description |
|---|
DrawReconstruction(INDArray data) |
DrawReconstruction(INDArray data,
int heightOffset,
int widthOffset) |
| Modifier and Type | Method and Description |
|---|---|
INDArray |
ImageTransformProcess.executeArray(ImageWritable image) |
| Modifier and Type | Method and Description |
|---|---|
INDArray |
WritablesToNDArrayFunction.apply(List<Writable> c) |
| Modifier and Type | Method and Description |
|---|---|
List<Writable> |
NDArrayToWritablesFunction.apply(INDArray arr) |
| Modifier and Type | Method and Description |
|---|---|
INDArray |
TokenizerBagOfWordsTermSequenceIndexTransform.convert(String text)
Convert the given text
in to an
INDArray
using the TokenizerFactory
specified in the constructor. |
INDArray |
MultiNlpTransform.transformFrom(List<List<Writable>> tokens) |
INDArray |
GazeteerTransform.transformFrom(List<List<Writable>> tokens) |
INDArray |
BagOfWordsTransform.transformFrom(List<List<Writable>> tokens)
|
INDArray |
MultiNlpTransform.transformFromObject(List<List<Object>> tokens) |
INDArray |
GazeteerTransform.transformFromObject(List<List<Object>> tokens) |
INDArray |
BagOfWordsTransform.transformFromObject(List<List<Object>> tokens)
Transform for a list of tokens
that are objects.
|
| Modifier and Type | Method and Description |
|---|---|
INDArray |
TfidfVectorizer.createVector(Object[] args) |
INDArray |
TfidfVectorizer.fitTransform(RecordReader reader) |
INDArray |
TfidfVectorizer.fitTransform(RecordReader reader,
Vectorizer.RecordCallBack callBack) |
INDArray |
TfidfVectorizer.transform(Record record) |
| Modifier and Type | Method and Description |
|---|---|
INDArray |
IOTiming.INDArrayCreationFunction.createFromRecord(List<Writable> record) |
| Modifier and Type | Method and Description |
|---|---|
void |
PythonVariables.addNDArray(String name,
INDArray value)
Add a null variable to
the set of variables
to describe the type but no value
|
| Constructor and Description |
|---|
NumpyArray(INDArray nd4jArray) |
| Modifier and Type | Method and Description |
|---|---|
static INDArray |
DataFrames.toMatrix(List<org.apache.spark.sql.Row> rows)
Convert a list of rows to a matrix
|
| Modifier and Type | Method and Description |
|---|---|
INDArray |
WritablesToNDArrayFunction.call(List<Writable> c) |
| Modifier and Type | Method and Description |
|---|---|
List<Writable> |
NDArrayToWritablesFunction.call(INDArray arr) |
| Modifier and Type | Method and Description |
|---|---|
INDArray |
TfidfVectorizer.transform(List<String> tokens) |
INDArray |
TextVectorizer.transform(List<String> tokens)
Transforms the matrix
|
INDArray |
BagOfWordsVectorizer.transform(List<String> tokens) |
INDArray |
TfidfVectorizer.transform(String text)
Transforms the matrix
|
INDArray |
TextVectorizer.transform(String text)
Transforms the matrix
|
INDArray |
BagOfWordsVectorizer.transform(String text) |
| Modifier and Type | Field and Description |
|---|---|
protected INDArray |
CentersHolder.argMin |
protected INDArray |
CentersHolder.distances |
| Modifier and Type | Method and Description |
|---|---|
static INDArray |
ClusterUtils.computeSquareDistancesFromNearestCluster(ClusterSet clusterSet,
List<Point> points,
INDArray previousDxs,
ExecutorService executorService) |
static INDArray |
ClusterUtils.computeWeightedProbaDistancesFromNearestCluster(ClusterSet clusterSet,
List<Point> points,
INDArray previousDxs) |
INDArray |
CentersHolder.getCenters() |
INDArray |
CentersHolder.getMinDistances(Point point,
Distance distanceFunction) |
| Modifier and Type | Method and Description |
|---|---|
void |
CentersHolder.addCenter(INDArray pointView) |
static INDArray |
ClusterUtils.computeSquareDistancesFromNearestCluster(ClusterSet clusterSet,
List<Point> points,
INDArray previousDxs,
ExecutorService executorService) |
static INDArray |
ClusterUtils.computeWeightedProbaDistancesFromNearestCluster(ClusterSet clusterSet,
List<Point> points,
INDArray previousDxs) |
static ReduceOp |
ClusterUtils.createDistanceFunctionOp(Distance distanceFunction,
INDArray x,
INDArray y) |
static ReduceOp |
ClusterUtils.createDistanceFunctionOp(Distance distanceFunction,
INDArray x,
INDArray y,
int... dimensions) |
static List<Point> |
Point.toPoints(INDArray matrix) |
| Modifier and Type | Method and Description |
|---|---|
static List<Point> |
Point.toPoints(List<INDArray> vectors) |
| Constructor and Description |
|---|
Point(INDArray array) |
Point(String id,
INDArray array) |
Point(String id,
String label,
INDArray array) |
| Modifier and Type | Method and Description |
|---|---|
INDArray |
KDTree.delete(INDArray point) |
| Modifier and Type | Method and Description |
|---|---|
List<Pair<Float,INDArray>> |
KDTree.knn(INDArray point,
float distance) |
Pair<Double,INDArray> |
KDTree.nn(INDArray point)
Query for nearest neighbor.
|
| Modifier and Type | Method and Description |
|---|---|
INDArray |
KDTree.delete(INDArray point) |
void |
HyperRect.enlargeTo(INDArray point) |
HyperRect |
HyperRect.getLower(INDArray hPoint,
int desc) |
HyperRect |
HyperRect.getUpper(INDArray hPoint,
int desc) |
void |
KDTree.insert(INDArray point)
Insert a point in to the tree
|
List<Pair<Float,INDArray>> |
KDTree.knn(INDArray point,
float distance) |
double |
HyperRect.minDistance(INDArray hPoint,
INDArray output) |
Pair<Double,INDArray> |
KDTree.nn(INDArray point)
Query for nearest neighbor.
|
static Pair<float[],float[]> |
HyperRect.point(INDArray vector) |
| Modifier and Type | Method and Description |
|---|---|
INDArray |
RandomProjectionLSH.bucket(INDArray query) |
INDArray |
LSH.bucket(INDArray query)
Returns the set of all vectors that could approximately be considered negihbors of the query,
without selection on the basis of distance or number of neighbors.
|
INDArray |
RandomProjectionLSH.entropy(INDArray data)
This picks uniformaly distributed random points on the unit of a sphere using the method of:
An efficient method for generating uniformly distributed points on the surface of an n-dimensional sphere
JS Hicks, RF Wheeling - Communications of the ACM, 1959
|
INDArray |
RandomProjectionLSH.hash(INDArray data)
Returns hash values for a particular query
|
INDArray |
RandomProjectionLSH.search(INDArray query,
double maxRange) |
INDArray |
LSH.search(INDArray query,
double maxRange)
Returns the approximate neighbors within a distance bound.
|
INDArray |
RandomProjectionLSH.search(INDArray query,
int k) |
INDArray |
LSH.search(INDArray query,
int k)
Returns the approximate neighbors within a k-closest bound
|
| Modifier and Type | Method and Description |
|---|---|
INDArray |
RandomProjectionLSH.bucket(INDArray query) |
INDArray |
LSH.bucket(INDArray query)
Returns the set of all vectors that could approximately be considered negihbors of the query,
without selection on the basis of distance or number of neighbors.
|
INDArray |
RandomProjectionLSH.entropy(INDArray data)
This picks uniformaly distributed random points on the unit of a sphere using the method of:
An efficient method for generating uniformly distributed points on the surface of an n-dimensional sphere
JS Hicks, RF Wheeling - Communications of the ACM, 1959
|
INDArray |
RandomProjectionLSH.hash(INDArray data)
Returns hash values for a particular query
|
void |
RandomProjectionLSH.makeIndex(INDArray data)
Populates the index.
|
void |
LSH.makeIndex(INDArray data)
Populates the index with data vectors.
|
INDArray |
RandomProjectionLSH.search(INDArray query,
double maxRange) |
INDArray |
LSH.search(INDArray query,
double maxRange)
Returns the approximate neighbors within a distance bound.
|
INDArray |
RandomProjectionLSH.search(INDArray query,
int k) |
INDArray |
LSH.search(INDArray query,
int k)
Returns the approximate neighbors within a k-closest bound
|
| Modifier and Type | Method and Description |
|---|---|
INDArray |
QuadTree.getCenterOfMass() |
| Modifier and Type | Method and Description |
|---|---|
void |
QuadTree.computeEdgeForces(INDArray rowP,
INDArray colP,
INDArray valP,
int N,
INDArray posF) |
void |
QuadTree.computeNonEdgeForces(int pointIndex,
double theta,
INDArray negativeForce,
org.nd4j.shade.guava.util.concurrent.AtomicDouble sumQ)
Compute non edge forces using barnes hut
|
boolean |
Cell.containsPoint(INDArray point)
Whether the given point is contained
within this cell
|
protected QuadTree |
QuadTree.findIndex(INDArray coordinates)
Returns the cell of this element
|
void |
QuadTree.setCenterOfMass(INDArray centerOfMass) |
| Constructor and Description |
|---|
QuadTree(INDArray data)
Pass in a matrix
|
QuadTree(QuadTree parent,
INDArray data,
Cell boundary) |
| Modifier and Type | Method and Description |
|---|---|
static INDArray |
RPUtils.computeDistanceMulti(String function,
INDArray x,
INDArray y,
INDArray result)
Compute the distance between 2 vectors
given a function name.
|
INDArray |
RPForest.getAllCandidates(INDArray input)
Get all candidates relative to a specific datapoint.
|
static INDArray |
RPUtils.getAllCandidates(INDArray x,
List<RPTree> trees,
String similarityFunction)
Get the search candidates as indices given the input
and similarity function
|
INDArray |
RPHyperPlanes.getHyperPlaneAt(int depth) |
INDArray |
RPTree.query(INDArray query,
int numResults) |
static INDArray |
RPUtils.queryAll(INDArray toQuery,
INDArray X,
List<RPTree> trees,
int n,
String similarityFunction)
Query all trees using the given input and data
|
INDArray |
RPForest.queryAll(INDArray toQuery,
int n)
Query results up to length n
nearest neighbors
|
| Modifier and Type | Method and Description |
|---|---|
void |
RPTree.addNodeAtIndex(int idx,
INDArray toAdd) |
void |
RPTree.buildTree(INDArray x)
Build the tree with the given input data
|
static void |
RPUtils.buildTree(RPTree tree,
RPNode from,
RPHyperPlanes planes,
INDArray X,
int maxSize,
int depth,
String similarityFunction)
Initialize the tree given the input parameters
|
static double |
RPUtils.computeDistance(String function,
INDArray x,
INDArray y)
Compute the distance between 2 vectors
given a function name.
|
static double |
RPUtils.computeDistance(String function,
INDArray x,
INDArray y,
INDArray result)
/**
Compute the distance between 2 vectors
given a function name.
|
static INDArray |
RPUtils.computeDistanceMulti(String function,
INDArray x,
INDArray y,
INDArray result)
Compute the distance between 2 vectors
given a function name.
|
void |
RPForest.fit(INDArray x)
Build the trees from the given dataset
|
INDArray |
RPForest.getAllCandidates(INDArray input)
Get all candidates relative to a specific datapoint.
|
static INDArray |
RPUtils.getAllCandidates(INDArray x,
List<RPTree> trees,
String similarityFunction)
Get the search candidates as indices given the input
and similarity function
|
List<Integer> |
RPTree.getCandidates(INDArray target) |
static List<Integer> |
RPUtils.getCandidates(INDArray x,
List<RPTree> roots,
String similarityFunction)
Get the search candidates as indices given the input
and similarity function
|
static <T extends DifferentialFunction> |
RPUtils.getOp(String name,
INDArray x,
INDArray y,
INDArray result) |
INDArray |
RPTree.query(INDArray query,
int numResults) |
static RPNode |
RPUtils.query(RPNode from,
RPHyperPlanes planes,
INDArray x,
String similarityFunction)
Query the tree starting from the given node
using the given hyper plane and similarity function
|
static INDArray |
RPUtils.queryAll(INDArray toQuery,
INDArray X,
List<RPTree> trees,
int n,
String similarityFunction)
Query all trees using the given input and data
|
INDArray |
RPForest.queryAll(INDArray toQuery,
int n)
Query results up to length n
nearest neighbors
|
static List<Pair<Double,Integer>> |
RPUtils.queryAllWithDistances(INDArray toQuery,
INDArray X,
List<RPTree> trees,
int n,
String similarityFunction)
Query all trees using the given input and data
|
List<Pair<Double,Integer>> |
RPTree.queryWithDistances(INDArray query,
int numResults)
Query all with the distances
sorted by index
|
List<Pair<Double,Integer>> |
RPForest.queryWithDistances(INDArray query,
int numResults)
Query all with the distances
sorted by index
|
static List<Pair<Double,Integer>> |
RPUtils.sortCandidates(INDArray x,
INDArray X,
List<Integer> candidates,
String similarityFunction)
Get the sorted distances given the
query vector, input data, given the list of possible search candidates
|
| Modifier and Type | Method and Description |
|---|---|
INDArray |
Cell.corner() |
INDArray |
SpTree.getCenterOfMass() |
INDArray |
Cell.width() |
| Modifier and Type | Method and Description |
|---|---|
void |
SpTree.computeEdgeForces(INDArray rowP,
INDArray colP,
INDArray valP,
int N,
INDArray posF)
Compute edge forces using barnes hut
|
void |
SpTree.computeNonEdgeForces(int pointIndex,
double theta,
INDArray negativeForce,
org.nd4j.shade.guava.util.concurrent.AtomicDouble sumQ)
Compute non edge forces using barnes hut
|
boolean |
Cell.contains(INDArray point) |
void |
Cell.setCorner(INDArray corner) |
void |
Cell.setWidth(INDArray width) |
| Constructor and Description |
|---|
DataPoint(int index,
INDArray point) |
DataPoint(int index,
INDArray point,
boolean invert) |
DataPoint(int index,
INDArray point,
String functionName) |
DataPoint(int index,
INDArray point,
String functionName,
boolean invert) |
HeapObject(int index,
INDArray point,
double distance) |
SpTree(INDArray data) |
SpTree(INDArray data,
Collection<INDArray> indices) |
SpTree(INDArray data,
Collection<INDArray> indices,
String similarityFunction) |
SpTree(SpTree parent,
INDArray data,
INDArray corner,
INDArray width,
Collection<INDArray> indices) |
SpTree(SpTree parent,
INDArray data,
INDArray corner,
INDArray width,
Collection<INDArray> indices,
String similarityFunction) |
| Constructor and Description |
|---|
SpTree(INDArray data,
Collection<INDArray> indices) |
SpTree(INDArray data,
Collection<INDArray> indices,
String similarityFunction) |
SpTree(SpTree parent,
INDArray data,
INDArray corner,
INDArray width,
Collection<INDArray> indices) |
SpTree(SpTree parent,
INDArray data,
INDArray corner,
INDArray width,
Collection<INDArray> indices,
String similarityFunction) |
| Modifier and Type | Field and Description |
|---|---|
protected List<INDArray> |
VPTree.NodeBuilder.list |
| Modifier and Type | Method and Description |
|---|---|
static INDArray |
VPTree.buildFromData(List<DataPoint> data)
Create an ndarray
from the datapoints
|
| Modifier and Type | Method and Description |
|---|---|
void |
VPTree.calcDistancesRelativeTo(INDArray basePoint,
INDArray distancesArr) |
void |
VPTree.calcDistancesRelativeTo(INDArray items,
INDArray basePoint,
INDArray distancesArr) |
double |
VPTree.distance(INDArray arr1,
INDArray arr2)
Euclidean distance
|
void |
VPTree.search(INDArray target,
int k,
List<DataPoint> results,
List<Double> distances) |
void |
VPTree.search(INDArray target,
int k,
List<DataPoint> results,
List<Double> distances,
boolean filterEqual) |
void |
VPTree.search(INDArray target,
int k,
List<DataPoint> results,
List<Double> distances,
boolean filterEqual,
boolean dropEdge) |
void |
VPTree.search(VPTree.Node node,
INDArray target,
int k,
PriorityQueue<HeapObject> pq,
double cTau) |
| Constructor and Description |
|---|
VPTree(INDArray items) |
VPTree(INDArray points,
boolean invert) |
VPTree(INDArray points,
boolean invert,
int workers) |
VPTree(INDArray items,
String similarityFunction) |
VPTree(INDArray items,
String similarityFunction,
boolean invert) |
VPTree(INDArray items,
String similarityFunction,
int workers,
boolean invert) |
VPTreeFillSearch(VPTree vpTree,
int k,
INDArray target) |
| Constructor and Description |
|---|
NodeBuilder(List<INDArray> list,
List<Integer> indices) |
| Modifier and Type | Method and Description |
|---|---|
MultiDataSet |
RecordReaderMultiDataSetIterator.nextMultiDataSet(Map<String,List<List<Writable>>> nextRRVals,
Map<String,List<INDArray>> nextRRValsBatched,
Map<String,List<List<List<Writable>>>> nextSeqRRVals,
List<RecordMetaDataComposableMap> nextMetas) |
| Modifier and Type | Method and Description |
|---|---|
static INDArray |
RandomMultiDataSetIterator.generate(long[] shape,
char order,
RandomMultiDataSetIterator.Values values)
Generate a random array with the specified shape and order
|
static INDArray |
RandomMultiDataSetIterator.generate(long[] shape,
RandomMultiDataSetIterator.Values values)
Generate a random array with the specified shape
|
| Constructor and Description |
|---|
INDArrayDataSetIterator(Iterable<Pair<INDArray,INDArray>> iterable,
int batchSize) |
INDArrayDataSetIterator(Iterable<Pair<INDArray,INDArray>> iterable,
int batchSize) |
| Modifier and Type | Method and Description |
|---|---|
protected INDArray[] |
VAEReconProbScoreCalculator.output(Model network,
INDArray[] input,
INDArray[] fMask,
INDArray[] lMask) |
protected INDArray[] |
VAEReconErrorScoreCalculator.output(Model network,
INDArray[] input,
INDArray[] fMask,
INDArray[] lMask) |
protected INDArray[] |
DataSetLossCalculator.output(Model network,
INDArray[] input,
INDArray[] fMask,
INDArray[] lMask) |
protected INDArray[] |
AutoencoderScoreCalculator.output(Model network,
INDArray[] input,
INDArray[] fMask,
INDArray[] lMask) |
protected INDArray |
VAEReconProbScoreCalculator.output(Model network,
INDArray input,
INDArray fMask,
INDArray lMask) |
protected INDArray |
VAEReconErrorScoreCalculator.output(Model net,
INDArray input,
INDArray fMask,
INDArray lMask) |
protected INDArray |
DataSetLossCalculator.output(Model network,
INDArray input,
INDArray fMask,
INDArray lMask) |
protected INDArray |
AutoencoderScoreCalculator.output(Model net,
INDArray input,
INDArray fMask,
INDArray lMask) |
| Modifier and Type | Method and Description |
|---|---|
protected INDArray[] |
VAEReconProbScoreCalculator.output(Model network,
INDArray[] input,
INDArray[] fMask,
INDArray[] lMask) |
protected INDArray[] |
VAEReconProbScoreCalculator.output(Model network,
INDArray[] input,
INDArray[] fMask,
INDArray[] lMask) |
protected INDArray[] |
VAEReconProbScoreCalculator.output(Model network,
INDArray[] input,
INDArray[] fMask,
INDArray[] lMask) |
protected INDArray[] |
VAEReconErrorScoreCalculator.output(Model network,
INDArray[] input,
INDArray[] fMask,
INDArray[] lMask) |
protected INDArray[] |
VAEReconErrorScoreCalculator.output(Model network,
INDArray[] input,
INDArray[] fMask,
INDArray[] lMask) |
protected INDArray[] |
VAEReconErrorScoreCalculator.output(Model network,
INDArray[] input,
INDArray[] fMask,
INDArray[] lMask) |
protected INDArray[] |
DataSetLossCalculator.output(Model network,
INDArray[] input,
INDArray[] fMask,
INDArray[] lMask) |
protected INDArray[] |
DataSetLossCalculator.output(Model network,
INDArray[] input,
INDArray[] fMask,
INDArray[] lMask) |
protected INDArray[] |
DataSetLossCalculator.output(Model network,
INDArray[] input,
INDArray[] fMask,
INDArray[] lMask) |
protected INDArray[] |
AutoencoderScoreCalculator.output(Model network,
INDArray[] input,
INDArray[] fMask,
INDArray[] lMask) |
protected INDArray[] |
AutoencoderScoreCalculator.output(Model network,
INDArray[] input,
INDArray[] fMask,
INDArray[] lMask) |
protected INDArray[] |
AutoencoderScoreCalculator.output(Model network,
INDArray[] input,
INDArray[] fMask,
INDArray[] lMask) |
protected INDArray |
VAEReconProbScoreCalculator.output(Model network,
INDArray input,
INDArray fMask,
INDArray lMask) |
protected INDArray |
VAEReconErrorScoreCalculator.output(Model net,
INDArray input,
INDArray fMask,
INDArray lMask) |
protected INDArray |
DataSetLossCalculator.output(Model network,
INDArray input,
INDArray fMask,
INDArray lMask) |
protected INDArray |
AutoencoderScoreCalculator.output(Model net,
INDArray input,
INDArray fMask,
INDArray lMask) |
protected double |
VAEReconProbScoreCalculator.scoreMinibatch(Model network,
INDArray[] features,
INDArray[] labels,
INDArray[] fMask,
INDArray[] lMask,
INDArray[] output) |
protected double |
VAEReconProbScoreCalculator.scoreMinibatch(Model network,
INDArray[] features,
INDArray[] labels,
INDArray[] fMask,
INDArray[] lMask,
INDArray[] output) |
protected double |
VAEReconProbScoreCalculator.scoreMinibatch(Model network,
INDArray[] features,
INDArray[] labels,
INDArray[] fMask,
INDArray[] lMask,
INDArray[] output) |
protected double |
VAEReconProbScoreCalculator.scoreMinibatch(Model network,
INDArray[] features,
INDArray[] labels,
INDArray[] fMask,
INDArray[] lMask,
INDArray[] output) |
protected double |
VAEReconProbScoreCalculator.scoreMinibatch(Model network,
INDArray[] features,
INDArray[] labels,
INDArray[] fMask,
INDArray[] lMask,
INDArray[] output) |
protected double |
VAEReconErrorScoreCalculator.scoreMinibatch(Model network,
INDArray[] features,
INDArray[] labels,
INDArray[] fMask,
INDArray[] lMask,
INDArray[] output) |
protected double |
VAEReconErrorScoreCalculator.scoreMinibatch(Model network,
INDArray[] features,
INDArray[] labels,
INDArray[] fMask,
INDArray[] lMask,
INDArray[] output) |
protected double |
VAEReconErrorScoreCalculator.scoreMinibatch(Model network,
INDArray[] features,
INDArray[] labels,
INDArray[] fMask,
INDArray[] lMask,
INDArray[] output) |
protected double |
VAEReconErrorScoreCalculator.scoreMinibatch(Model network,
INDArray[] features,
INDArray[] labels,
INDArray[] fMask,
INDArray[] lMask,
INDArray[] output) |
protected double |
VAEReconErrorScoreCalculator.scoreMinibatch(Model network,
INDArray[] features,
INDArray[] labels,
INDArray[] fMask,
INDArray[] lMask,
INDArray[] output) |
protected double |
DataSetLossCalculator.scoreMinibatch(Model network,
INDArray[] features,
INDArray[] labels,
INDArray[] fMask,
INDArray[] lMask,
INDArray[] output) |
protected double |
DataSetLossCalculator.scoreMinibatch(Model network,
INDArray[] features,
INDArray[] labels,
INDArray[] fMask,
INDArray[] lMask,
INDArray[] output) |
protected double |
DataSetLossCalculator.scoreMinibatch(Model network,
INDArray[] features,
INDArray[] labels,
INDArray[] fMask,
INDArray[] lMask,
INDArray[] output) |
protected double |
DataSetLossCalculator.scoreMinibatch(Model network,
INDArray[] features,
INDArray[] labels,
INDArray[] fMask,
INDArray[] lMask,
INDArray[] output) |
protected double |
DataSetLossCalculator.scoreMinibatch(Model network,
INDArray[] features,
INDArray[] labels,
INDArray[] fMask,
INDArray[] lMask,
INDArray[] output) |
protected double |
AutoencoderScoreCalculator.scoreMinibatch(Model network,
INDArray[] features,
INDArray[] labels,
INDArray[] fMask,
INDArray[] lMask,
INDArray[] output) |
protected double |
AutoencoderScoreCalculator.scoreMinibatch(Model network,
INDArray[] features,
INDArray[] labels,
INDArray[] fMask,
INDArray[] lMask,
INDArray[] output) |
protected double |
AutoencoderScoreCalculator.scoreMinibatch(Model network,
INDArray[] features,
INDArray[] labels,
INDArray[] fMask,
INDArray[] lMask,
INDArray[] output) |
protected double |
AutoencoderScoreCalculator.scoreMinibatch(Model network,
INDArray[] features,
INDArray[] labels,
INDArray[] fMask,
INDArray[] lMask,
INDArray[] output) |
protected double |
AutoencoderScoreCalculator.scoreMinibatch(Model network,
INDArray[] features,
INDArray[] labels,
INDArray[] fMask,
INDArray[] lMask,
INDArray[] output) |
protected double |
VAEReconProbScoreCalculator.scoreMinibatch(Model net,
INDArray features,
INDArray labels,
INDArray fMask,
INDArray lMask,
INDArray output) |
protected double |
VAEReconErrorScoreCalculator.scoreMinibatch(Model network,
INDArray features,
INDArray labels,
INDArray fMask,
INDArray lMask,
INDArray output) |
protected double |
AutoencoderScoreCalculator.scoreMinibatch(Model network,
INDArray features,
INDArray labels,
INDArray fMask,
INDArray lMask,
INDArray output) |
| Modifier and Type | Method and Description |
|---|---|
static INDArray[] |
BaseScoreCalculator.arr(INDArray in) |
static INDArray |
BaseScoreCalculator.get0(INDArray[] in) |
protected INDArray[] |
BaseMLNScoreCalculator.output(MultiLayerNetwork network,
INDArray[] input,
INDArray[] fMask,
INDArray[] lMask) |
protected INDArray |
BaseMLNScoreCalculator.output(MultiLayerNetwork network,
INDArray input,
INDArray fMask,
INDArray lMask) |
protected abstract INDArray[] |
BaseScoreCalculator.output(T network,
INDArray[] input,
INDArray[] fMask,
INDArray[] lMask) |
protected abstract INDArray |
BaseScoreCalculator.output(T network,
INDArray input,
INDArray fMask,
INDArray lMask) |
| Modifier and Type | Method and Description |
|---|---|
static INDArray[] |
BaseScoreCalculator.arr(INDArray in) |
static INDArray |
BaseScoreCalculator.get0(INDArray[] in) |
protected INDArray[] |
BaseMLNScoreCalculator.output(MultiLayerNetwork network,
INDArray[] input,
INDArray[] fMask,
INDArray[] lMask) |
protected INDArray[] |
BaseMLNScoreCalculator.output(MultiLayerNetwork network,
INDArray[] input,
INDArray[] fMask,
INDArray[] lMask) |
protected INDArray[] |
BaseMLNScoreCalculator.output(MultiLayerNetwork network,
INDArray[] input,
INDArray[] fMask,
INDArray[] lMask) |
protected INDArray |
BaseMLNScoreCalculator.output(MultiLayerNetwork network,
INDArray input,
INDArray fMask,
INDArray lMask) |
protected abstract INDArray[] |
BaseScoreCalculator.output(T network,
INDArray[] input,
INDArray[] fMask,
INDArray[] lMask) |
protected abstract INDArray[] |
BaseScoreCalculator.output(T network,
INDArray[] input,
INDArray[] fMask,
INDArray[] lMask) |
protected abstract INDArray[] |
BaseScoreCalculator.output(T network,
INDArray[] input,
INDArray[] fMask,
INDArray[] lMask) |
protected abstract INDArray |
BaseScoreCalculator.output(T network,
INDArray input,
INDArray fMask,
INDArray lMask) |
protected double |
BaseMLNScoreCalculator.scoreMinibatch(MultiLayerNetwork network,
INDArray[] features,
INDArray[] labels,
INDArray[] fMask,
INDArray[] lMask,
INDArray[] output) |
protected double |
BaseMLNScoreCalculator.scoreMinibatch(MultiLayerNetwork network,
INDArray[] features,
INDArray[] labels,
INDArray[] fMask,
INDArray[] lMask,
INDArray[] output) |
protected double |
BaseMLNScoreCalculator.scoreMinibatch(MultiLayerNetwork network,
INDArray[] features,
INDArray[] labels,
INDArray[] fMask,
INDArray[] lMask,
INDArray[] output) |
protected double |
BaseMLNScoreCalculator.scoreMinibatch(MultiLayerNetwork network,
INDArray[] features,
INDArray[] labels,
INDArray[] fMask,
INDArray[] lMask,
INDArray[] output) |
protected double |
BaseMLNScoreCalculator.scoreMinibatch(MultiLayerNetwork network,
INDArray[] features,
INDArray[] labels,
INDArray[] fMask,
INDArray[] lMask,
INDArray[] output) |
protected abstract double |
BaseScoreCalculator.scoreMinibatch(T network,
INDArray[] features,
INDArray[] labels,
INDArray[] fMask,
INDArray[] lMask,
INDArray[] output) |
protected abstract double |
BaseScoreCalculator.scoreMinibatch(T network,
INDArray[] features,
INDArray[] labels,
INDArray[] fMask,
INDArray[] lMask,
INDArray[] output) |
protected abstract double |
BaseScoreCalculator.scoreMinibatch(T network,
INDArray[] features,
INDArray[] labels,
INDArray[] fMask,
INDArray[] lMask,
INDArray[] output) |
protected abstract double |
BaseScoreCalculator.scoreMinibatch(T network,
INDArray[] features,
INDArray[] labels,
INDArray[] fMask,
INDArray[] lMask,
INDArray[] output) |
protected abstract double |
BaseScoreCalculator.scoreMinibatch(T network,
INDArray[] features,
INDArray[] labels,
INDArray[] fMask,
INDArray[] lMask,
INDArray[] output) |
protected double |
BaseScoreCalculator.scoreMinibatch(T network,
INDArray features,
INDArray labels,
INDArray fMask,
INDArray lMask,
INDArray output) |
| Constructor and Description |
|---|
Evaluation(INDArray costArray)
Deprecated.
Use ND4J Evaluation class, which has the same interface:
Evaluation.Metric |
Evaluation(List<String> labels,
INDArray costArray)
Deprecated.
Use ND4J Evaluation class, which has the same interface:
Evaluation.Metric |
EvaluationBinary(INDArray decisionThreshold)
Deprecated.
|
| Modifier and Type | Method and Description |
|---|---|
static boolean |
GradientCheckUtil.checkGradients(ComputationGraph graph,
double epsilon,
double maxRelError,
double minAbsoluteError,
boolean print,
boolean exitOnFirstError,
INDArray[] inputs,
INDArray[] labels)
Check backprop gradients for a ComputationGraph
|
static boolean |
GradientCheckUtil.checkGradients(ComputationGraph graph,
double epsilon,
double maxRelError,
double minAbsoluteError,
boolean print,
boolean exitOnFirstError,
INDArray[] inputs,
INDArray[] labels)
Check backprop gradients for a ComputationGraph
|
static boolean |
GradientCheckUtil.checkGradients(ComputationGraph graph,
double epsilon,
double maxRelError,
double minAbsoluteError,
boolean print,
boolean exitOnFirstError,
INDArray[] inputs,
INDArray[] labels,
INDArray[] fMask,
INDArray[] lMask) |
static boolean |
GradientCheckUtil.checkGradients(ComputationGraph graph,
double epsilon,
double maxRelError,
double minAbsoluteError,
boolean print,
boolean exitOnFirstError,
INDArray[] inputs,
INDArray[] labels,
INDArray[] fMask,
INDArray[] lMask) |
static boolean |
GradientCheckUtil.checkGradients(ComputationGraph graph,
double epsilon,
double maxRelError,
double minAbsoluteError,
boolean print,
boolean exitOnFirstError,
INDArray[] inputs,
INDArray[] labels,
INDArray[] fMask,
INDArray[] lMask) |
static boolean |
GradientCheckUtil.checkGradients(ComputationGraph graph,
double epsilon,
double maxRelError,
double minAbsoluteError,
boolean print,
boolean exitOnFirstError,
INDArray[] inputs,
INDArray[] labels,
INDArray[] fMask,
INDArray[] lMask) |
static boolean |
GradientCheckUtil.checkGradients(ComputationGraph graph,
double epsilon,
double maxRelError,
double minAbsoluteError,
boolean print,
boolean exitOnFirstError,
INDArray[] inputs,
INDArray[] labels,
INDArray[] fMask,
INDArray[] lMask,
Set<String> excludeParams) |
static boolean |
GradientCheckUtil.checkGradients(ComputationGraph graph,
double epsilon,
double maxRelError,
double minAbsoluteError,
boolean print,
boolean exitOnFirstError,
INDArray[] inputs,
INDArray[] labels,
INDArray[] fMask,
INDArray[] lMask,
Set<String> excludeParams) |
static boolean |
GradientCheckUtil.checkGradients(ComputationGraph graph,
double epsilon,
double maxRelError,
double minAbsoluteError,
boolean print,
boolean exitOnFirstError,
INDArray[] inputs,
INDArray[] labels,
INDArray[] fMask,
INDArray[] lMask,
Set<String> excludeParams) |
static boolean |
GradientCheckUtil.checkGradients(ComputationGraph graph,
double epsilon,
double maxRelError,
double minAbsoluteError,
boolean print,
boolean exitOnFirstError,
INDArray[] inputs,
INDArray[] labels,
INDArray[] fMask,
INDArray[] lMask,
Set<String> excludeParams) |
static boolean |
GradientCheckUtil.checkGradients(ComputationGraph graph,
double epsilon,
double maxRelError,
double minAbsoluteError,
boolean print,
boolean exitOnFirstError,
INDArray[] inputs,
INDArray[] labels,
INDArray[] fMask,
INDArray[] lMask,
Set<String> excludeParams,
Consumer<ComputationGraph> callEachIter) |
static boolean |
GradientCheckUtil.checkGradients(ComputationGraph graph,
double epsilon,
double maxRelError,
double minAbsoluteError,
boolean print,
boolean exitOnFirstError,
INDArray[] inputs,
INDArray[] labels,
INDArray[] fMask,
INDArray[] lMask,
Set<String> excludeParams,
Consumer<ComputationGraph> callEachIter) |
static boolean |
GradientCheckUtil.checkGradients(ComputationGraph graph,
double epsilon,
double maxRelError,
double minAbsoluteError,
boolean print,
boolean exitOnFirstError,
INDArray[] inputs,
INDArray[] labels,
INDArray[] fMask,
INDArray[] lMask,
Set<String> excludeParams,
Consumer<ComputationGraph> callEachIter) |
static boolean |
GradientCheckUtil.checkGradients(ComputationGraph graph,
double epsilon,
double maxRelError,
double minAbsoluteError,
boolean print,
boolean exitOnFirstError,
INDArray[] inputs,
INDArray[] labels,
INDArray[] fMask,
INDArray[] lMask,
Set<String> excludeParams,
Consumer<ComputationGraph> callEachIter) |
static boolean |
GradientCheckUtil.checkGradients(ComputationGraph graph,
double epsilon,
double maxRelError,
double minAbsoluteError,
boolean print,
boolean exitOnFirstError,
INDArray[] inputs,
INDArray[] labels,
INDArray[] fMask,
INDArray[] lMask,
Set<String> excludeParams,
Integer rngSeedResetEachIter) |
static boolean |
GradientCheckUtil.checkGradients(ComputationGraph graph,
double epsilon,
double maxRelError,
double minAbsoluteError,
boolean print,
boolean exitOnFirstError,
INDArray[] inputs,
INDArray[] labels,
INDArray[] fMask,
INDArray[] lMask,
Set<String> excludeParams,
Integer rngSeedResetEachIter) |
static boolean |
GradientCheckUtil.checkGradients(ComputationGraph graph,
double epsilon,
double maxRelError,
double minAbsoluteError,
boolean print,
boolean exitOnFirstError,
INDArray[] inputs,
INDArray[] labels,
INDArray[] fMask,
INDArray[] lMask,
Set<String> excludeParams,
Integer rngSeedResetEachIter) |
static boolean |
GradientCheckUtil.checkGradients(ComputationGraph graph,
double epsilon,
double maxRelError,
double minAbsoluteError,
boolean print,
boolean exitOnFirstError,
INDArray[] inputs,
INDArray[] labels,
INDArray[] fMask,
INDArray[] lMask,
Set<String> excludeParams,
Integer rngSeedResetEachIter) |
static boolean |
GradientCheckUtil.checkGradients(MultiLayerNetwork mln,
double epsilon,
double maxRelError,
double minAbsoluteError,
boolean print,
boolean exitOnFirstError,
INDArray input,
INDArray labels)
Check backprop gradients for a MultiLayerNetwork.
|
static boolean |
GradientCheckUtil.checkGradients(MultiLayerNetwork mln,
double epsilon,
double maxRelError,
double minAbsoluteError,
boolean print,
boolean exitOnFirstError,
INDArray input,
INDArray labels,
INDArray inputMask,
INDArray labelMask) |
static boolean |
GradientCheckUtil.checkGradients(MultiLayerNetwork mln,
double epsilon,
double maxRelError,
double minAbsoluteError,
boolean print,
boolean exitOnFirstError,
INDArray input,
INDArray labels,
INDArray inputMask,
INDArray labelMask,
boolean subset,
int maxPerParam) |
static boolean |
GradientCheckUtil.checkGradients(MultiLayerNetwork mln,
double epsilon,
double maxRelError,
double minAbsoluteError,
boolean print,
boolean exitOnFirstError,
INDArray input,
INDArray labels,
INDArray inputMask,
INDArray labelMask,
boolean subset,
int maxPerParam,
Set<String> excludeParams) |
static boolean |
GradientCheckUtil.checkGradients(MultiLayerNetwork mln,
double epsilon,
double maxRelError,
double minAbsoluteError,
boolean print,
boolean exitOnFirstError,
INDArray input,
INDArray labels,
INDArray inputMask,
INDArray labelMask,
boolean subset,
int maxPerParam,
Set<String> excludeParams,
Consumer<MultiLayerNetwork> callEachIter) |
static boolean |
GradientCheckUtil.checkGradients(MultiLayerNetwork mln,
double epsilon,
double maxRelError,
double minAbsoluteError,
boolean print,
boolean exitOnFirstError,
INDArray input,
INDArray labels,
INDArray inputMask,
INDArray labelMask,
boolean subset,
int maxPerParam,
Set<String> excludeParams,
Integer rngSeedResetEachIter) |
static boolean |
GradientCheckUtil.checkGradients(MultiLayerNetwork mln,
double epsilon,
double maxRelError,
double minAbsoluteError,
boolean print,
boolean exitOnFirstError,
INDArray input,
INDArray labels,
Set<String> excludeParams) |
static boolean |
GradientCheckUtil.checkGradientsPretrainLayer(Layer layer,
double epsilon,
double maxRelError,
double minAbsoluteError,
boolean print,
boolean exitOnFirstError,
INDArray input,
int rngSeed)
Check backprop gradients for a pretrain layer
NOTE: gradient checking pretrain layers can be difficult...
|
| Modifier and Type | Method and Description |
|---|---|
INDArray |
GraphVectors.getVertexVector(int vertexIdx) |
INDArray |
GraphVectors.getVertexVector(Vertex<V> vertex) |
| Modifier and Type | Field and Description |
|---|---|
protected INDArray |
InMemoryGraphLookupTable.outWeights |
protected INDArray |
InMemoryGraphLookupTable.vertexVectors |
| Modifier and Type | Method and Description |
|---|---|
INDArray |
InMemoryGraphLookupTable.getInnerNodeVector(int innerNode) |
INDArray |
InMemoryGraphLookupTable.getOutWeights() |
INDArray |
InMemoryGraphLookupTable.getVector(int idx) |
INDArray |
GraphVectorLookupTable.getVector(int idx)
Get the vector for the vertex with index idx
|
INDArray |
GraphVectorsImpl.getVertexVector(int vertexIdx) |
INDArray |
GraphVectorsImpl.getVertexVector(Vertex<V> vertex) |
INDArray |
InMemoryGraphLookupTable.getVertexVectors() |
INDArray[][] |
InMemoryGraphLookupTable.vectorsAndGradients(int first,
int second)
Returns vertex vector and vector gradients, plus inner node vectors and inner node gradients
Specifically, out[0] are vectors, out[1] are gradients for the corresponding vectors out[0][0] is vector for first vertex; out[0][1] is gradient for this vertex vector out[0][i] (i>0) is the inner node vector along path to second vertex; out[1][i] is gradient for inner node vertex This design is used primarily to aid in testing (numerical gradient checks) |
| Modifier and Type | Method and Description |
|---|---|
void |
InMemoryGraphLookupTable.setVertexVectors(INDArray vertexVectors) |
| Modifier and Type | Method and Description |
|---|---|
INDArray |
CnnSentenceDataSetIterator.loadSingleSentence(String sentence)
Generally used post training time to load a single sentence for predictions
|
| Modifier and Type | Method and Description |
|---|---|
INDArray |
MalmoObservationSpacePosition.getHigh() |
INDArray |
MalmoObservationSpacePixels.getHigh() |
INDArray |
MalmoObservationSpaceGrid.getHigh() |
INDArray |
MalmoObservationSpacePosition.getLow() |
INDArray |
MalmoObservationSpacePixels.getLow() |
INDArray |
MalmoObservationSpaceGrid.getLow() |
| Modifier and Type | Method and Description |
|---|---|
INDArray |
WeightLookupTable.getWeights() |
INDArray |
WeightLookupTable.loadCodes(int[] codes)
Loads the co-occurrences for the given codes
|
INDArray |
WeightLookupTable.vector(String word) |
| Modifier and Type | Method and Description |
|---|---|
Iterator<INDArray> |
WeightLookupTable.vectors()
Iterates through all of the vectors in the cache
|
| Modifier and Type | Method and Description |
|---|---|
void |
WeightLookupTable.putCode(int codeIndex,
INDArray code) |
void |
WeightLookupTable.putVector(String word,
INDArray vector)
Inserts a word vector
|
| Modifier and Type | Field and Description |
|---|---|
protected INDArray |
InMemoryLookupTable.syn0 |
protected INDArray |
InMemoryLookupTable.syn1 |
protected INDArray |
InMemoryLookupTable.syn1Neg |
protected INDArray |
InMemoryLookupTable.table |
| Modifier and Type | Field and Description |
|---|---|
protected Map<Integer,INDArray> |
InMemoryLookupTable.codes |
| Modifier and Type | Method and Description |
|---|---|
INDArray |
InMemoryLookupTable.getSyn0() |
INDArray |
InMemoryLookupTable.getSyn1() |
INDArray |
InMemoryLookupTable.getSyn1Neg() |
INDArray |
InMemoryLookupTable.getTable() |
INDArray |
InMemoryLookupTable.getWeights() |
INDArray |
InMemoryLookupTable.loadCodes(int[] codes)
Loads the co-occurrences for the given codes
|
INDArray |
InMemoryLookupTable.WeightIterator.next() |
INDArray |
InMemoryLookupTable.vector(String word) |
| Modifier and Type | Method and Description |
|---|---|
Map<Integer,INDArray> |
InMemoryLookupTable.getCodes() |
Iterator<INDArray> |
InMemoryLookupTable.vectors() |
| Modifier and Type | Method and Description |
|---|---|
void |
InMemoryLookupTable.putCode(int codeIndex,
INDArray code) |
void |
InMemoryLookupTable.putVector(String word,
INDArray vector)
Inserts a word vector
|
void |
InMemoryLookupTable.setSyn0(INDArray syn0) |
void |
InMemoryLookupTable.setSyn1(INDArray syn1) |
void |
InMemoryLookupTable.setSyn1Neg(INDArray syn1Neg) |
void |
InMemoryLookupTable.setTable(INDArray table) |
| Modifier and Type | Method and Description |
|---|---|
void |
InMemoryLookupTable.setCodes(Map<Integer,INDArray> codes) |
| Modifier and Type | Method and Description |
|---|---|
INDArray |
SequenceLearningAlgorithm.inferSequence(Sequence<T> sequence,
long nextRandom,
double learningRate,
double minLearningRate,
int iterations)
This method does training on previously unseen paragraph, and returns inferred vector
|
| Modifier and Type | Method and Description |
|---|---|
void |
CBOW.iterateSample(T currentWord,
int[] windowWords,
boolean[] wordStatuses,
AtomicLong nextRandom,
double alpha,
boolean isInference,
int numLabels,
boolean trainWords,
INDArray inferenceVector) |
double |
SkipGram.iterateSample(T w1,
T lastWord,
AtomicLong nextRandom,
double alpha,
boolean isInference,
INDArray inferenceVector) |
| Modifier and Type | Field and Description |
|---|---|
protected INDArray |
DM.syn0 |
protected INDArray |
DM.syn1 |
protected INDArray |
DM.syn1Neg |
protected INDArray |
DM.table |
| Modifier and Type | Method and Description |
|---|---|
INDArray |
DM.inferSequence(Sequence<T> sequence,
long nr,
double learningRate,
double minLearningRate,
int iterations)
This method does training on previously unseen paragraph, and returns inferred vector
|
INDArray |
DBOW.inferSequence(Sequence<T> sequence,
long nextRandom,
double learningRate,
double minLearningRate,
int iterations)
This method does training on previously unseen paragraph, and returns inferred vector
|
| Modifier and Type | Method and Description |
|---|---|
protected void |
DBOW.dbow(int i,
Sequence<T> sequence,
int b,
AtomicLong nextRandom,
double alpha,
boolean isInference,
INDArray inferenceVector,
BatchSequences<T> batchSequences) |
void |
DM.dm(int i,
Sequence<T> sequence,
int b,
AtomicLong nextRandom,
double alpha,
List<T> labels,
boolean isInference,
INDArray inferenceVector,
BatchSequences<T> batchSequences) |
| Modifier and Type | Method and Description |
|---|---|
static void |
WordVectorSerializer.writeTsneFormat(Glove vec,
INDArray tsne,
File csv)
Write the tsne format
|
static void |
WordVectorSerializer.writeTsneFormat(Word2Vec vec,
INDArray tsne,
File csv)
Write the tsne format
|
| Modifier and Type | Method and Description |
|---|---|
Collection<String> |
ModelUtils.wordsNearest(INDArray words,
int top)
Words nearest based on positive and negative words
* @param top the top n words
|
Collection<String> |
ModelUtils.wordsNearestSum(INDArray words,
int top) |
| Modifier and Type | Method and Description |
|---|---|
protected INDArray |
BasicModelUtils.adjustRank(INDArray words) |
| Modifier and Type | Method and Description |
|---|---|
protected INDArray |
BasicModelUtils.adjustRank(INDArray words) |
Collection<String> |
TreeModelUtils.wordsNearest(INDArray words,
int top) |
Collection<String> |
FlatModelUtils.wordsNearest(INDArray words,
int top)
This method does full scan against whole vocabulary, building descending list of similar words
|
Collection<String> |
BasicModelUtils.wordsNearest(INDArray words,
int top)
Words nearest based on positive and negative words
* @param top the top n words
|
Collection<String> |
BasicModelUtils.wordsNearestSum(INDArray words,
int top)
Words nearest based on positive and negative words
* @param top the top n words
|
| Modifier and Type | Method and Description |
|---|---|
INDArray |
WordVectorsImpl.getWordVectorMatrix(String word) |
INDArray |
WordVectors.getWordVectorMatrix(String word)
Get the word vector for a given matrix
|
INDArray |
WordVectorsImpl.getWordVectorMatrixNormalized(String word)
Returns the word vector divided by the norm2 of the array
|
INDArray |
WordVectors.getWordVectorMatrixNormalized(String word)
Returns the word vector divided by the norm2 of the array
|
INDArray |
WordVectorsImpl.getWordVectors(Collection<String> labels)
This method returns 2D array, where each row represents corresponding label
|
INDArray |
WordVectors.getWordVectors(Collection<String> labels)
This method returns 2D array, where each row represents corresponding word/label
|
INDArray |
WordVectorsImpl.getWordVectorsMean(Collection<String> labels)
This method returns mean vector, built from words/labels passed in
|
INDArray |
WordVectors.getWordVectorsMean(Collection<String> labels)
This method returns mean vector, built from words/labels passed in
|
| Modifier and Type | Method and Description |
|---|---|
void |
WordVectorsImpl.loadWeightsInto(INDArray array) |
Collection<String> |
WordVectorsImpl.wordsNearest(INDArray words,
int top)
Words nearest based on positive and negative words
* @param top the top n words
|
Collection<String> |
WordVectors.wordsNearest(INDArray words,
int top) |
Collection<String> |
WordVectorsImpl.wordsNearestSum(INDArray words,
int top)
Words nearest based on positive and negative words
* @param top the top n words
|
Collection<String> |
WordVectors.wordsNearestSum(INDArray words,
int top) |
| Modifier and Type | Method and Description |
|---|---|
INDArray |
FastText.getWordVectorMatrix(String word) |
INDArray |
FastText.getWordVectorMatrixNormalized(String word) |
INDArray |
FastText.getWordVectors(Collection<String> labels) |
INDArray |
FastText.getWordVectorsMean(Collection<String> labels) |
| Modifier and Type | Method and Description |
|---|---|
void |
FastText.loadWeightsInto(INDArray array) |
Collection<String> |
FastText.wordsNearest(INDArray words,
int top) |
Collection<String> |
FastText.wordsNearestSum(INDArray words,
int top) |
| Modifier and Type | Method and Description |
|---|---|
INDArray |
GloveWeightLookupTable.getBias()
Deprecated.
|
| Modifier and Type | Method and Description |
|---|---|
void |
GloveWeightLookupTable.setBias(INDArray bias)
Deprecated.
|
| Modifier and Type | Method and Description |
|---|---|
INDArray |
Node2Vec.inferVector(Collection<Vertex<V>> vertices)
Deprecated.
|
| Modifier and Type | Field and Description |
|---|---|
protected INDArray |
ParagraphVectors.labelsMatrix |
| Modifier and Type | Method and Description |
|---|---|
INDArray |
ParagraphVectors.BlindInferenceCallable.call() |
INDArray |
ParagraphVectors.inferVector(LabelledDocument document)
This method calculates inferred vector for given document, with default parameters for learning rate and iterations
|
INDArray |
ParagraphVectors.inferVector(LabelledDocument document,
double learningRate,
double minLearningRate,
int iterations)
This method calculates inferred vector for given document
|
INDArray |
ParagraphVectors.inferVector(List<VocabWord> document)
This method calculates inferred vector for given list of words, with default parameters for learning rate and iterations
|
INDArray |
ParagraphVectors.inferVector(List<VocabWord> document,
double learningRate,
double minLearningRate,
int iterations)
This method calculates inferred vector for given document
|
INDArray |
ParagraphVectors.inferVector(String text)
This method calculates inferred vector for given text, with default parameters for learning rate and iterations
|
INDArray |
ParagraphVectors.inferVector(String text,
double learningRate,
double minLearningRate,
int iterations)
This method calculates inferred vector for given text
|
| Modifier and Type | Method and Description |
|---|---|
Pair<String,INDArray> |
ParagraphVectors.InferenceCallable.call() |
Future<Pair<String,INDArray>> |
ParagraphVectors.inferVectorBatched(LabelledDocument document)
This method implements batched inference, based on Java Future parallelism model.
|
List<INDArray> |
ParagraphVectors.inferVectorBatched(List<String> documents)
This method does inference on a given List<String>
|
Future<INDArray> |
ParagraphVectors.inferVectorBatched(String document)
This method implements batched inference, based on Java Future parallelism model.
|
| Modifier and Type | Method and Description |
|---|---|
Collection<String> |
ParagraphVectors.nearestLabels(INDArray labelVector,
int topN)
This method returns top N labels nearest to specified features vector
|
| Modifier and Type | Method and Description |
|---|---|
INDArray |
SequenceVectors.getWordVectorMatrix(String word) |
| Modifier and Type | Method and Description |
|---|---|
INDArray |
SequenceElement.getHistoricalGradient()
Deprecated.
|
| Modifier and Type | Method and Description |
|---|---|
void |
SequenceElement.setHistoricalGradient(INDArray gradient)
Deprecated.
|
| Modifier and Type | Method and Description |
|---|---|
INDArray |
StaticWord2Vec.getWordVectorMatrix(String word)
Get the word vector for a given matrix
|
INDArray |
StaticWord2Vec.getWordVectorMatrixNormalized(String word)
Returns the word vector divided by the norm2 of the array
|
INDArray |
StaticWord2Vec.getWordVectors(Collection<String> labels)
This method returns 2D array, where each row represents corresponding word/label
|
INDArray |
StaticWord2Vec.getWordVectorsMean(Collection<String> labels)
This method returns mean vector, built from words/labels passed in
|
| Modifier and Type | Method and Description |
|---|---|
void |
StaticWord2Vec.loadWeightsInto(INDArray array) |
Collection<String> |
StaticWord2Vec.wordsNearest(INDArray words,
int top) |
Collection<String> |
StaticWord2Vec.wordsNearestSum(INDArray words,
int top) |
| Modifier and Type | Method and Description |
|---|---|
NearestNeighborsResults |
NearestNeighborsClient.knnNew(int k,
INDArray arr)
Run a k nearest neighbors search
on a NEW data point
|
| Modifier and Type | Method and Description |
|---|---|
List<DetectedObject> |
YoloModelAdapter.apply(INDArray... outputs) |
double[][] |
Regression2dAdapter.apply(INDArray... outputs) |
int[] |
ArgmaxAdapter.apply(INDArray... outputs)
This method does conversion from INDArrays to int[], where each element will represents position of the highest element in output INDArray
I.e.
|
List<DetectedObject> |
YoloModelAdapter.apply(Model model,
INDArray[] inputs,
INDArray[] masks,
INDArray[] labelsMasks) |
List<DetectedObject> |
YoloModelAdapter.apply(Model model,
INDArray[] inputs,
INDArray[] masks,
INDArray[] labelsMasks) |
List<DetectedObject> |
YoloModelAdapter.apply(Model model,
INDArray[] inputs,
INDArray[] masks,
INDArray[] labelsMasks) |
| Modifier and Type | Method and Description |
|---|---|
INDArray |
Layer.activate(boolean training,
LayerWorkspaceMgr workspaceMgr)
Perform forward pass and return the activations array with the last set input
|
INDArray |
Layer.activate(INDArray input,
boolean training,
LayerWorkspaceMgr mgr)
Perform forward pass and return the activations array with the specified input
|
INDArray |
Trainable.getGradientsViewArray() |
INDArray |
Model.getGradientsViewArray() |
INDArray |
Layer.getMaskArray() |
INDArray |
Model.getParam(String param)
Get the parameter
|
INDArray |
Updater.getStateViewArray() |
INDArray |
Model.input()
The input/feature matrix for the model
|
INDArray |
Trainable.params() |
INDArray |
NeuralNetwork.params()
This method returns model parameters as single INDArray
|
INDArray |
Model.params()
Parameters of the model (if any)
|
INDArray |
NeuralNetwork.updaterState()
This method returns updater state (if applicable), null otherwise
|
| Modifier and Type | Method and Description |
|---|---|
Pair<Gradient,INDArray> |
Layer.backpropGradient(INDArray epsilon,
LayerWorkspaceMgr workspaceMgr)
Calculate the gradient relative to the error in the next layer
|
Pair<INDArray,MaskState> |
Layer.feedForwardMaskArray(INDArray maskArray,
MaskState currentMaskState,
int minibatchSize)
Feed forward the input mask array, setting in the layer as appropriate.
|
Map<String,INDArray> |
ParamInitializer.getGradientsFromFlattened(NeuralNetConfiguration conf,
INDArray gradientView)
Return a map of gradients (in their standard non-flattened representation), taken from the flattened (row vector) gradientView array.
|
Map<String,INDArray> |
ParamInitializer.init(NeuralNetConfiguration conf,
INDArray paramsView,
boolean initializeParams)
Initialize the parameters
|
Map<String,INDArray> |
Model.paramTable()
The param table
|
Map<String,INDArray> |
Trainable.paramTable(boolean backpropOnly) |
Map<String,INDArray> |
Model.paramTable(boolean backpropParamsOnly)
Table of parameters by key, for backprop
For many models (dense layers, etc) - all parameters are backprop parameters
|
| Modifier and Type | Method and Description |
|---|---|
INDArray |
Layer.activate(INDArray input,
boolean training,
LayerWorkspaceMgr mgr)
Perform forward pass and return the activations array with the specified input
|
T |
ModelAdapter.apply(Model model,
INDArray[] inputs,
INDArray[] inputMasks,
INDArray[] labelsMasks)
This method invokes model internally, and does convertion to T
|
T |
ModelAdapter.apply(Model model,
INDArray[] inputs,
INDArray[] inputMasks,
INDArray[] labelsMasks)
This method invokes model internally, and does convertion to T
|
T |
ModelAdapter.apply(Model model,
INDArray[] inputs,
INDArray[] inputMasks,
INDArray[] labelsMasks)
This method invokes model internally, and does convertion to T
|
Pair<Gradient,INDArray> |
Layer.backpropGradient(INDArray epsilon,
LayerWorkspaceMgr workspaceMgr)
Calculate the gradient relative to the error in the next layer
|
double |
Classifier.f1Score(INDArray examples,
INDArray labels)
Returns the f1 score for the given examples.
|
Pair<INDArray,MaskState> |
Layer.feedForwardMaskArray(INDArray maskArray,
MaskState currentMaskState,
int minibatchSize)
Feed forward the input mask array, setting in the layer as appropriate.
|
void |
Classifier.fit(INDArray examples,
INDArray labels)
Fit the model
|
void |
Classifier.fit(INDArray examples,
int[] labels)
Fit the model
|
void |
Model.fit(INDArray data,
LayerWorkspaceMgr workspaceMgr)
Fit the model to the given data
|
Map<String,INDArray> |
ParamInitializer.getGradientsFromFlattened(NeuralNetConfiguration conf,
INDArray gradientView)
Return a map of gradients (in their standard non-flattened representation), taken from the flattened (row vector) gradientView array.
|
Map<String,INDArray> |
ParamInitializer.init(NeuralNetConfiguration conf,
INDArray paramsView,
boolean initializeParams)
Initialize the parameters
|
int[] |
Classifier.predict(INDArray examples)
Takes in a list of examples
For each row, returns a label
|
void |
Model.setBackpropGradientsViewArray(INDArray gradients)
Set the gradients array as a view of the full (backprop) network parameters
NOTE: this is intended to be used internally in MultiLayerNetwork and ComputationGraph, not by users.
|
void |
Layer.setInput(INDArray input,
LayerWorkspaceMgr workspaceMgr)
Set the layer input.
|
void |
Layer.setMaskArray(INDArray maskArray)
Set the mask array.
|
void |
Model.setParam(String key,
INDArray val)
Set the parameter with a new ndarray
|
void |
Model.setParams(INDArray params)
Set the parameters for this model.
|
void |
Model.setParamsViewArray(INDArray params)
Set the initial parameters array as a view of the full (backprop) network parameters
NOTE: this is intended to be used internally in MultiLayerNetwork and ComputationGraph, not by users.
|
void |
Updater.setStateViewArray(Trainable layer,
INDArray viewArray,
boolean initialize)
Set the internal (historical) state view array for this updater
|
void |
Model.update(INDArray gradient,
String paramType)
Perform one update applying the gradient
|
| Modifier and Type | Method and Description |
|---|---|
void |
Model.setParamTable(Map<String,INDArray> paramTable)
Setter for the param table
|
| Modifier and Type | Method and Description |
|---|---|
INDArray |
IOutputLayer.computeScoreForExamples(double fullNetworkRegScore,
LayerWorkspaceMgr workspaceMgr)
Compute the score for each example individually, after labels and input have been set.
|
INDArray |
IOutputLayer.getLabels()
Get the labels array previously set with
IOutputLayer.setLabels(INDArray) |
INDArray |
RecurrentLayer.rnnActivateUsingStoredState(INDArray input,
boolean training,
boolean storeLastForTBPTT,
LayerWorkspaceMgr workspaceMg)
Similar to rnnTimeStep, this method is used for activations using the state
stored in the stateMap as the initialization.
|
INDArray |
RecurrentLayer.rnnTimeStep(INDArray input,
LayerWorkspaceMgr workspaceMgr)
Do one or more time steps using the previous time step state stored in stateMap.
|
| Modifier and Type | Method and Description |
|---|---|
Map<String,INDArray> |
RecurrentLayer.rnnGetPreviousState()
Returns a shallow copy of the RNN stateMap (that contains the stored history for use in methods such
as rnnTimeStep
|
Map<String,INDArray> |
RecurrentLayer.rnnGetTBPTTState()
Get the RNN truncated backpropagations through time (TBPTT) state for the recurrent layer.
|
Pair<Gradient,INDArray> |
RecurrentLayer.tbpttBackpropGradient(INDArray epsilon,
int tbpttBackLength,
LayerWorkspaceMgr workspaceMgr)
Truncated BPTT equivalent of Layer.backpropGradient().
|
| Modifier and Type | Method and Description |
|---|---|
INDArray |
RecurrentLayer.rnnActivateUsingStoredState(INDArray input,
boolean training,
boolean storeLastForTBPTT,
LayerWorkspaceMgr workspaceMg)
Similar to rnnTimeStep, this method is used for activations using the state
stored in the stateMap as the initialization.
|
INDArray |
RecurrentLayer.rnnTimeStep(INDArray input,
LayerWorkspaceMgr workspaceMgr)
Do one or more time steps using the previous time step state stored in stateMap.
|
void |
IOutputLayer.setLabels(INDArray labels)
Set the labels array for this output layer
|
Pair<Gradient,INDArray> |
RecurrentLayer.tbpttBackpropGradient(INDArray epsilon,
int tbpttBackLength,
LayerWorkspaceMgr workspaceMgr)
Truncated BPTT equivalent of Layer.backpropGradient().
|
| Modifier and Type | Method and Description |
|---|---|
void |
RecurrentLayer.rnnSetPreviousState(Map<String,INDArray> stateMap)
Set the stateMap (stored history).
|
void |
RecurrentLayer.rnnSetTBPTTState(Map<String,INDArray> state)
Set the RNN truncated backpropagations through time (TBPTT) state for the recurrent layer.
|
| Modifier and Type | Method and Description |
|---|---|
INDArray |
InputPreProcessor.backprop(INDArray output,
int miniBatchSize,
LayerWorkspaceMgr workspaceMgr)
Reverse the preProcess during backprop.
|
INDArray |
InputPreProcessor.preProcess(INDArray input,
int miniBatchSize,
LayerWorkspaceMgr workspaceMgr)
Pre preProcess input/activations for a multi layer network
|
| Modifier and Type | Method and Description |
|---|---|
Pair<INDArray,MaskState> |
InputPreProcessor.feedForwardMaskArray(INDArray maskArray,
MaskState currentMaskState,
int minibatchSize) |
| Modifier and Type | Method and Description |
|---|---|
INDArray |
InputPreProcessor.backprop(INDArray output,
int miniBatchSize,
LayerWorkspaceMgr workspaceMgr)
Reverse the preProcess during backprop.
|
Pair<INDArray,MaskState> |
InputPreProcessor.feedForwardMaskArray(INDArray maskArray,
MaskState currentMaskState,
int minibatchSize) |
INDArray |
InputPreProcessor.preProcess(INDArray input,
int miniBatchSize,
LayerWorkspaceMgr workspaceMgr)
Pre preProcess input/activations for a multi layer network
|
| Modifier and Type | Method and Description |
|---|---|
void |
UnitNormConstraint.apply(INDArray param) |
void |
NonNegativeConstraint.apply(INDArray param) |
void |
MinMaxNormConstraint.apply(INDArray param) |
void |
MaxNormConstraint.apply(INDArray param) |
abstract void |
BaseConstraint.apply(INDArray param) |
| Modifier and Type | Method and Description |
|---|---|
INDArray |
SpatialDropout.applyDropout(INDArray inputActivations,
INDArray output,
int iteration,
int epoch,
LayerWorkspaceMgr workspaceMgr) |
INDArray |
IDropout.applyDropout(INDArray inputActivations,
INDArray resultArray,
int iteration,
int epoch,
LayerWorkspaceMgr workspaceMgr) |
INDArray |
GaussianNoise.applyDropout(INDArray inputActivations,
INDArray output,
int iteration,
int epoch,
LayerWorkspaceMgr workspaceMgr) |
INDArray |
GaussianDropout.applyDropout(INDArray inputActivations,
INDArray output,
int iteration,
int epoch,
LayerWorkspaceMgr workspaceMgr) |
INDArray |
Dropout.applyDropout(INDArray inputActivations,
INDArray output,
int iteration,
int epoch,
LayerWorkspaceMgr workspaceMgr) |
INDArray |
AlphaDropout.applyDropout(INDArray inputActivations,
INDArray output,
int iteration,
int epoch,
LayerWorkspaceMgr workspaceMgr) |
INDArray |
SpatialDropout.backprop(INDArray gradAtOutput,
INDArray gradAtInput,
int iteration,
int epoch) |
INDArray |
IDropout.backprop(INDArray gradAtOutput,
INDArray gradAtInput,
int iteration,
int epoch)
Perform backprop.
|
INDArray |
GaussianNoise.backprop(INDArray gradAtOutput,
INDArray gradAtInput,
int iteration,
int epoch) |
INDArray |
GaussianDropout.backprop(INDArray gradAtOutput,
INDArray gradAtInput,
int iteration,
int epoch) |
INDArray |
Dropout.backprop(INDArray gradAtOutput,
INDArray gradAtInput,
int iteration,
int epoch) |
INDArray |
AlphaDropout.backprop(INDArray gradAtOutput,
INDArray gradAtInput,
int iteration,
int epoch) |
| Modifier and Type | Method and Description |
|---|---|
void |
DropoutHelper.applyDropout(INDArray inputActivations,
INDArray resultArray,
double dropoutInputRetainProb)
Apply the dropout during forward pass
|
INDArray |
SpatialDropout.applyDropout(INDArray inputActivations,
INDArray output,
int iteration,
int epoch,
LayerWorkspaceMgr workspaceMgr) |
INDArray |
IDropout.applyDropout(INDArray inputActivations,
INDArray resultArray,
int iteration,
int epoch,
LayerWorkspaceMgr workspaceMgr) |
INDArray |
GaussianNoise.applyDropout(INDArray inputActivations,
INDArray output,
int iteration,
int epoch,
LayerWorkspaceMgr workspaceMgr) |
INDArray |
GaussianDropout.applyDropout(INDArray inputActivations,
INDArray output,
int iteration,
int epoch,
LayerWorkspaceMgr workspaceMgr) |
INDArray |
Dropout.applyDropout(INDArray inputActivations,
INDArray output,
int iteration,
int epoch,
LayerWorkspaceMgr workspaceMgr) |
INDArray |
AlphaDropout.applyDropout(INDArray inputActivations,
INDArray output,
int iteration,
int epoch,
LayerWorkspaceMgr workspaceMgr) |
void |
DropoutHelper.backprop(INDArray gradAtOutput,
INDArray gradAtInput)
Perform backpropagation.
|
INDArray |
SpatialDropout.backprop(INDArray gradAtOutput,
INDArray gradAtInput,
int iteration,
int epoch) |
INDArray |
IDropout.backprop(INDArray gradAtOutput,
INDArray gradAtInput,
int iteration,
int epoch)
Perform backprop.
|
INDArray |
GaussianNoise.backprop(INDArray gradAtOutput,
INDArray gradAtInput,
int iteration,
int epoch) |
INDArray |
GaussianDropout.backprop(INDArray gradAtOutput,
INDArray gradAtInput,
int iteration,
int epoch) |
INDArray |
Dropout.backprop(INDArray gradAtOutput,
INDArray gradAtInput,
int iteration,
int epoch) |
INDArray |
AlphaDropout.backprop(INDArray gradAtOutput,
INDArray gradAtInput,
int iteration,
int epoch) |
| Modifier and Type | Method and Description |
|---|---|
Pair<INDArray,MaskState> |
AttentionVertex.feedForwardMaskArrays(INDArray[] maskArrays,
MaskState currentMaskState,
int minibatchSize) |
| Modifier and Type | Method and Description |
|---|---|
Pair<INDArray,MaskState> |
AttentionVertex.feedForwardMaskArrays(INDArray[] maskArrays,
MaskState currentMaskState,
int minibatchSize) |
GraphVertex |
UnstackVertex.instantiate(ComputationGraph graph,
String name,
int idx,
INDArray paramsView,
boolean initializeParams,
DataType networkDatatype) |
GraphVertex |
SubsetVertex.instantiate(ComputationGraph graph,
String name,
int idx,
INDArray paramsView,
boolean initializeParams,
DataType networkDatatype) |
GraphVertex |
StackVertex.instantiate(ComputationGraph graph,
String name,
int idx,
INDArray paramsView,
boolean initializeParams,
DataType networkDatatype) |
GraphVertex |
ShiftVertex.instantiate(ComputationGraph graph,
String name,
int idx,
INDArray paramsView,
boolean initializeParams,
DataType networkDatatype) |
GraphVertex |
ScaleVertex.instantiate(ComputationGraph graph,
String name,
int idx,
INDArray paramsView,
boolean initializeParams,
DataType networkDatatype) |
GraphVertex |
ReshapeVertex.instantiate(ComputationGraph graph,
String name,
int idx,
INDArray paramsView,
boolean initializeParams,
DataType networkDatatype) |
GraphVertex |
PreprocessorVertex.instantiate(ComputationGraph graph,
String name,
int idx,
INDArray paramsView,
boolean initializeParams,
DataType networkDatatype) |
GraphVertex |
PoolHelperVertex.instantiate(ComputationGraph graph,
String name,
int idx,
INDArray paramsView,
boolean initializeParams,
DataType networkDatatype) |
GraphVertex |
MergeVertex.instantiate(ComputationGraph graph,
String name,
int idx,
INDArray paramsView,
boolean initializeParams,
DataType networkDatatype) |
GraphVertex |
LayerVertex.instantiate(ComputationGraph graph,
String name,
int idx,
INDArray paramsView,
boolean initializeParams,
DataType networkDatatype) |
GraphVertex |
L2Vertex.instantiate(ComputationGraph graph,
String name,
int idx,
INDArray paramsView,
boolean initializeParams,
DataType networkDatatype) |
GraphVertex |
L2NormalizeVertex.instantiate(ComputationGraph graph,
String name,
int idx,
INDArray paramsView,
boolean initializeParams,
DataType networkDatatype) |
abstract GraphVertex |
GraphVertex.instantiate(ComputationGraph graph,
String name,
int idx,
INDArray paramsView,
boolean initializeParams,
DataType networkDatatype)
Create a
GraphVertex instance, for the given computation graph,
given the configuration instance. |
GraphVertex |
FrozenVertex.instantiate(ComputationGraph graph,
String name,
int idx,
INDArray paramsView,
boolean initializeParams,
DataType networkDatatype) |
GraphVertex |
ElementWiseVertex.instantiate(ComputationGraph graph,
String name,
int idx,
INDArray paramsView,
boolean initializeParams,
DataType networkDatatype) |
| Modifier and Type | Method and Description |
|---|---|
void |
AttentionVertex.initializeParameters(Map<String,INDArray> params) |
| Modifier and Type | Method and Description |
|---|---|
ReverseTimeSeriesVertex |
ReverseTimeSeriesVertex.instantiate(ComputationGraph graph,
String name,
int idx,
INDArray paramsView,
boolean initializeParams,
DataType networkDatatype) |
LastTimeStepVertex |
LastTimeStepVertex.instantiate(ComputationGraph graph,
String name,
int idx,
INDArray paramsView,
boolean initializeParams,
DataType networkDatatype) |
GraphVertex |
DuplicateToTimeSeriesVertex.instantiate(ComputationGraph graph,
String name,
int idx,
INDArray paramsView,
boolean initializeParams,
DataType networkDatatype) |
| Modifier and Type | Method and Description |
|---|---|
static InputType |
InputType.inferInputType(INDArray inputArray) |
static InputType[] |
InputType.inferInputTypes(INDArray... inputArrays) |
| Modifier and Type | Method and Description |
|---|---|
Pair<INDArray,MaskState> |
LearnedSelfAttentionLayer.feedForwardMaskArray(INDArray maskArray,
MaskState currentMaskState,
int minibatchSize) |
| Modifier and Type | Method and Description |
|---|---|
Pair<INDArray,MaskState> |
LearnedSelfAttentionLayer.feedForwardMaskArray(INDArray maskArray,
MaskState currentMaskState,
int minibatchSize) |
Layer |
ZeroPaddingLayer.instantiate(NeuralNetConfiguration conf,
Collection<TrainingListener> trainingListeners,
int layerIndex,
INDArray layerParamsView,
boolean initializeParams,
DataType networkDataType) |
Layer |
ZeroPadding3DLayer.instantiate(NeuralNetConfiguration conf,
Collection<TrainingListener> iterationListeners,
int layerIndex,
INDArray layerParamsView,
boolean initializeParams,
DataType networkDataType) |
Layer |
ZeroPadding1DLayer.instantiate(NeuralNetConfiguration conf,
Collection<TrainingListener> trainingListeners,
int layerIndex,
INDArray layerParamsView,
boolean initializeParams,
DataType networkDataType) |
Layer |
Upsampling3D.instantiate(NeuralNetConfiguration conf,
Collection<TrainingListener> iterationListeners,
int layerIndex,
INDArray layerParamsView,
boolean initializeParams,
DataType networkDataType) |
Layer |
Upsampling2D.instantiate(NeuralNetConfiguration conf,
Collection<TrainingListener> trainingListeners,
int layerIndex,
INDArray layerParamsView,
boolean initializeParams,
DataType networkDataType) |
Layer |
Upsampling1D.instantiate(NeuralNetConfiguration conf,
Collection<TrainingListener> trainingListeners,
int layerIndex,
INDArray layerParamsView,
boolean initializeParams,
DataType networkDataType) |
Layer |
SubsamplingLayer.instantiate(NeuralNetConfiguration conf,
Collection<TrainingListener> trainingListeners,
int layerIndex,
INDArray layerParamsView,
boolean initializeParams,
DataType networkDataType) |
Layer |
Subsampling3DLayer.instantiate(NeuralNetConfiguration conf,
Collection<TrainingListener> iterationListeners,
int layerIndex,
INDArray layerParamsView,
boolean initializeParams,
DataType networkDataType) |
Layer |
Subsampling1DLayer.instantiate(NeuralNetConfiguration conf,
Collection<TrainingListener> trainingListeners,
int layerIndex,
INDArray layerParamsView,
boolean initializeParams,
DataType networkDataType) |
Layer |
SpaceToDepthLayer.instantiate(NeuralNetConfiguration conf,
Collection<TrainingListener> trainingListeners,
int layerIndex,
INDArray layerParamsView,
boolean initializeParams,
DataType networkDataType) |
Layer |
SpaceToBatchLayer.instantiate(NeuralNetConfiguration conf,
Collection<TrainingListener> trainingListeners,
int layerIndex,
INDArray layerParamsView,
boolean initializeParams,
DataType networkDataType) |
Layer |
SeparableConvolution2D.instantiate(NeuralNetConfiguration conf,
Collection<TrainingListener> trainingListeners,
int layerIndex,
INDArray layerParamsView,
boolean initializeParams,
DataType networkDataType) |
Layer |
RnnOutputLayer.instantiate(NeuralNetConfiguration conf,
Collection<TrainingListener> trainingListeners,
int layerIndex,
INDArray layerParamsView,
boolean initializeParams,
DataType networkDataType) |
Layer |
RnnLossLayer.instantiate(NeuralNetConfiguration conf,
Collection<TrainingListener> trainingListeners,
int layerIndex,
INDArray layerParamsView,
boolean initializeParams,
DataType networkDataType) |
Layer |
PReLULayer.instantiate(NeuralNetConfiguration conf,
Collection<TrainingListener> trainingListeners,
int layerIndex,
INDArray layerParamsView,
boolean initializeParams,
DataType networkDataType) |
Layer |
OutputLayer.instantiate(NeuralNetConfiguration conf,
Collection<TrainingListener> trainingListeners,
int layerIndex,
INDArray layerParamsView,
boolean initializeParams,
DataType networkDataType) |
Layer |
LSTM.instantiate(NeuralNetConfiguration conf,
Collection<TrainingListener> trainingListeners,
int layerIndex,
INDArray layerParamsView,
boolean initializeParams,
DataType networkDataType) |
Layer |
LossLayer.instantiate(NeuralNetConfiguration conf,
Collection<TrainingListener> trainingListeners,
int layerIndex,
INDArray layerParamsView,
boolean initializeParams,
DataType networkDataType) |
Layer |
LocalResponseNormalization.instantiate(NeuralNetConfiguration conf,
Collection<TrainingListener> trainingListeners,
int layerIndex,
INDArray layerParamsView,
boolean initializeParams,
DataType networkDataType) |
abstract Layer |
Layer.instantiate(NeuralNetConfiguration conf,
Collection<TrainingListener> trainingListeners,
int layerIndex,
INDArray layerParamsView,
boolean initializeParams,
DataType networkDataType) |
Layer |
GravesLSTM.instantiate(NeuralNetConfiguration conf,
Collection<TrainingListener> trainingListeners,
int layerIndex,
INDArray layerParamsView,
boolean initializeParams,
DataType networkDataType)
Deprecated.
|
Layer |
GravesBidirectionalLSTM.instantiate(NeuralNetConfiguration conf,
Collection<TrainingListener> trainingListeners,
int layerIndex,
INDArray layerParamsView,
boolean initializeParams,
DataType networkDataType)
Deprecated.
|
Layer |
GlobalPoolingLayer.instantiate(NeuralNetConfiguration conf,
Collection<TrainingListener> trainingListeners,
int layerIndex,
INDArray layerParamsView,
boolean initializeParams,
DataType networkDataType) |
Layer |
EmbeddingSequenceLayer.instantiate(NeuralNetConfiguration conf,
Collection<TrainingListener> trainingListeners,
int layerIndex,
INDArray layerParamsView,
boolean initializeParams,
DataType networkDataType) |
Layer |
EmbeddingLayer.instantiate(NeuralNetConfiguration conf,
Collection<TrainingListener> trainingListeners,
int layerIndex,
INDArray layerParamsView,
boolean initializeParams,
DataType networkDataType) |
Layer |
DropoutLayer.instantiate(NeuralNetConfiguration conf,
Collection<TrainingListener> trainingListeners,
int layerIndex,
INDArray layerParamsView,
boolean initializeParams,
DataType networkDataType) |
Layer |
DepthwiseConvolution2D.instantiate(NeuralNetConfiguration conf,
Collection<TrainingListener> trainingListeners,
int layerIndex,
INDArray layerParamsView,
boolean initializeParams,
DataType networkDataType) |
Layer |
DenseLayer.instantiate(NeuralNetConfiguration conf,
Collection<TrainingListener> trainingListeners,
int layerIndex,
INDArray layerParamsView,
boolean initializeParams,
DataType networkDataType) |
Layer |
Deconvolution2D.instantiate(NeuralNetConfiguration conf,
Collection<TrainingListener> trainingListeners,
int layerIndex,
INDArray layerParamsView,
boolean initializeParams,
DataType networkDataType) |
Layer |
ConvolutionLayer.instantiate(NeuralNetConfiguration conf,
Collection<TrainingListener> trainingListeners,
int layerIndex,
INDArray layerParamsView,
boolean initializeParams,
DataType networkDataType) |
Layer |
Convolution3D.instantiate(NeuralNetConfiguration conf,
Collection<TrainingListener> iterationListeners,
int layerIndex,
INDArray layerParamsView,
boolean initializeParams,
DataType networkDataType) |
Layer |
Convolution1DLayer.instantiate(NeuralNetConfiguration conf,
Collection<TrainingListener> trainingListeners,
int layerIndex,
INDArray layerParamsView,
boolean initializeParams,
DataType networkDataType) |
Layer |
CnnLossLayer.instantiate(NeuralNetConfiguration conf,
Collection<TrainingListener> trainingListeners,
int layerIndex,
INDArray layerParamsView,
boolean initializeParams,
DataType networkDataType) |
Layer |
Cnn3DLossLayer.instantiate(NeuralNetConfiguration conf,
Collection<TrainingListener> trainingListeners,
int layerIndex,
INDArray layerParamsView,
boolean initializeParams,
DataType networkDataType) |
Layer |
CenterLossOutputLayer.instantiate(NeuralNetConfiguration conf,
Collection<TrainingListener> trainingListeners,
int layerIndex,
INDArray layerParamsView,
boolean initializeParams,
DataType networkDataType) |
Layer |
BatchNormalization.instantiate(NeuralNetConfiguration conf,
Collection<TrainingListener> trainingListeners,
int layerIndex,
INDArray layerParamsView,
boolean initializeParams,
DataType networkDataType) |
Layer |
AutoEncoder.instantiate(NeuralNetConfiguration conf,
Collection<TrainingListener> trainingListeners,
int layerIndex,
INDArray layerParamsView,
boolean initializeParams,
DataType networkDataType) |
Layer |
ActivationLayer.instantiate(NeuralNetConfiguration conf,
Collection<TrainingListener> trainingListeners,
int layerIndex,
INDArray layerParamsView,
boolean initializeParams,
DataType networkDataType) |
void |
RecurrentAttentionLayer.validateInput(INDArray input) |
EmbeddingSequenceLayer.Builder |
EmbeddingSequenceLayer.Builder.weightInit(INDArray vectors)
Initialize the embedding layer using values from the specified array.
|
EmbeddingLayer.Builder |
EmbeddingLayer.Builder.weightInit(INDArray vectors)
Initialize the embedding layer using values from the specified array.
|
| Modifier and Type | Method and Description |
|---|---|
void |
SelfAttentionLayer.initializeParameters(Map<String,INDArray> params) |
void |
RecurrentAttentionLayer.initializeParameters(Map<String,INDArray> params) |
void |
PrimaryCapsules.initializeParameters(Map<String,INDArray> params) |
void |
LocallyConnected2D.initializeParameters(Map<String,INDArray> params) |
void |
LocallyConnected1D.initializeParameters(Map<String,INDArray> params) |
void |
LearnedSelfAttentionLayer.initializeParameters(Map<String,INDArray> params) |
void |
CapsuleLayer.initializeParameters(Map<String,INDArray> params) |
| Modifier and Type | Method and Description |
|---|---|
Layer |
Cropping3D.instantiate(NeuralNetConfiguration conf,
Collection<TrainingListener> iterationListeners,
int layerIndex,
INDArray layerParamsView,
boolean initializeParams,
DataType networkDataType) |
Layer |
Cropping2D.instantiate(NeuralNetConfiguration conf,
Collection<TrainingListener> trainingListeners,
int layerIndex,
INDArray layerParamsView,
boolean initializeParams,
DataType networkDataType) |
Layer |
Cropping1D.instantiate(NeuralNetConfiguration conf,
Collection<TrainingListener> trainingListeners,
int layerIndex,
INDArray layerParamsView,
boolean initializeParams,
DataType networkDataType) |
| Modifier and Type | Method and Description |
|---|---|
Layer |
RepeatVector.instantiate(NeuralNetConfiguration conf,
Collection<TrainingListener> trainingListeners,
int layerIndex,
INDArray layerParamsView,
boolean initializeParams,
DataType networkDataType) |
Layer |
FrozenLayerWithBackprop.instantiate(NeuralNetConfiguration conf,
Collection<TrainingListener> trainingListeners,
int layerIndex,
INDArray layerParamsView,
boolean initializeParams,
DataType networkDataType) |
Layer |
FrozenLayer.instantiate(NeuralNetConfiguration conf,
Collection<TrainingListener> trainingListeners,
int layerIndex,
INDArray layerParamsView,
boolean initializeParams,
DataType networkDataType) |
Layer |
ElementWiseMultiplicationLayer.instantiate(NeuralNetConfiguration conf,
Collection<TrainingListener> trainingListeners,
int layerIndex,
INDArray layerParamsView,
boolean initializeParams,
DataType networkDataType) |
| Modifier and Type | Method and Description |
|---|---|
Yolo2OutputLayer.Builder |
Yolo2OutputLayer.Builder.boundingBoxPriors(INDArray boundingBoxes)
Bounding box priors dimensions [width, height].
|
Layer |
Yolo2OutputLayer.instantiate(NeuralNetConfiguration conf,
Collection<TrainingListener> trainingListeners,
int layerIndex,
INDArray layerParamsView,
boolean initializeParams,
DataType networkDataType) |
| Modifier and Type | Method and Description |
|---|---|
Layer |
TimeDistributed.instantiate(NeuralNetConfiguration conf,
Collection<TrainingListener> trainingListeners,
int layerIndex,
INDArray layerParamsView,
boolean initializeParams,
DataType networkDataType) |
Layer |
SimpleRnn.instantiate(NeuralNetConfiguration conf,
Collection<TrainingListener> trainingListeners,
int layerIndex,
INDArray layerParamsView,
boolean initializeParams,
DataType networkDataType) |
Layer |
LastTimeStep.instantiate(NeuralNetConfiguration conf,
Collection<TrainingListener> trainingListeners,
int layerIndex,
INDArray layerParamsView,
boolean initializeParams,
DataType networkDataType) |
Layer |
Bidirectional.instantiate(NeuralNetConfiguration conf,
Collection<TrainingListener> trainingListeners,
int layerIndex,
INDArray layerParamsView,
boolean initializeParams,
DataType networkDataType) |
| Modifier and Type | Method and Description |
|---|---|
INDArray |
AbstractSameDiffLayer.onesMaskForInput(INDArray input)
This method generates an "all ones" mask array for use in the SameDiff model when none is provided.
|
| Modifier and Type | Method and Description |
|---|---|
Pair<INDArray,MaskState> |
SameDiffLayer.feedForwardMaskArray(INDArray maskArray,
MaskState currentMaskState,
int minibatchSize) |
Pair<INDArray,MaskState> |
SameDiffVertex.feedForwardMaskArrays(INDArray[] maskArrays,
MaskState currentMaskState,
int minibatchSize) |
| Modifier and Type | Method and Description |
|---|---|
Pair<INDArray,MaskState> |
SameDiffLayer.feedForwardMaskArray(INDArray maskArray,
MaskState currentMaskState,
int minibatchSize) |
Pair<INDArray,MaskState> |
SameDiffVertex.feedForwardMaskArrays(INDArray[] maskArrays,
MaskState currentMaskState,
int minibatchSize) |
protected void |
AbstractSameDiffLayer.initWeights(int fanIn,
int fanOut,
WeightInit weightInit,
INDArray array) |
GraphVertex |
SameDiffVertex.instantiate(ComputationGraph graph,
String name,
int idx,
INDArray paramsView,
boolean initializeParams,
DataType networkDatatype) |
Layer |
SameDiffOutputLayer.instantiate(NeuralNetConfiguration conf,
Collection<TrainingListener> trainingListeners,
int layerIndex,
INDArray layerParamsView,
boolean initializeParams,
DataType networkDataType) |
Layer |
SameDiffLayer.instantiate(NeuralNetConfiguration conf,
Collection<TrainingListener> trainingListeners,
int layerIndex,
INDArray layerParamsView,
boolean initializeParams,
DataType networkDataType) |
abstract Layer |
AbstractSameDiffLayer.instantiate(NeuralNetConfiguration conf,
Collection<TrainingListener> trainingListeners,
int layerIndex,
INDArray layerParamsView,
boolean initializeParams,
DataType networkDataType) |
INDArray |
AbstractSameDiffLayer.onesMaskForInput(INDArray input)
This method generates an "all ones" mask array for use in the SameDiff model when none is provided.
|
void |
SameDiffLayer.validateInput(INDArray input)
Validate input arrays to confirm that they fulfill the assumptions of the layer.
|
void |
SameDiffVertex.validateInput(INDArray[] input)
Validate input arrays to confirm that they fulfill the assumptions of the layer.
|
| Modifier and Type | Method and Description |
|---|---|
abstract void |
SameDiffVertex.initializeParameters(Map<String,INDArray> params)
Set the initial parameter values for this layer, if required
|
void |
SameDiffLambdaVertex.initializeParameters(Map<String,INDArray> params) |
void |
SameDiffLambdaLayer.initializeParameters(Map<String,INDArray> params) |
abstract void |
AbstractSameDiffLayer.initializeParameters(Map<String,INDArray> params)
Set the initial parameter values for this layer, if required
|
| Modifier and Type | Method and Description |
|---|---|
Layer |
MaskZeroLayer.instantiate(NeuralNetConfiguration conf,
Collection<TrainingListener> trainingListeners,
int layerIndex,
INDArray layerParamsView,
boolean initializeParams,
DataType networkDataType) |
Layer |
MaskLayer.instantiate(NeuralNetConfiguration conf,
Collection<TrainingListener> trainingListeners,
int layerIndex,
INDArray layerParamsView,
boolean initializeParams,
DataType networkDataType) |
| Modifier and Type | Method and Description |
|---|---|
INDArray |
CompositeReconstructionDistribution.computeLossFunctionScoreArray(INDArray data,
INDArray reconstruction) |
INDArray |
ReconstructionDistribution.exampleNegLogProbability(INDArray x,
INDArray preOutDistributionParams)
Calculate the negative log probability for each example individually
|
INDArray |
LossFunctionWrapper.exampleNegLogProbability(INDArray x,
INDArray preOutDistributionParams) |
INDArray |
GaussianReconstructionDistribution.exampleNegLogProbability(INDArray x,
INDArray preOutDistributionParams) |
INDArray |
ExponentialReconstructionDistribution.exampleNegLogProbability(INDArray x,
INDArray preOutDistributionParams) |
INDArray |
CompositeReconstructionDistribution.exampleNegLogProbability(INDArray x,
INDArray preOutDistributionParams) |
INDArray |
BernoulliReconstructionDistribution.exampleNegLogProbability(INDArray x,
INDArray preOutDistributionParams) |
INDArray |
ReconstructionDistribution.generateAtMean(INDArray preOutDistributionParams)
Generate a sample from P(x|z), where x = E[P(x|z)]
i.e., return the mean value for the distribution
|
INDArray |
LossFunctionWrapper.generateAtMean(INDArray preOutDistributionParams) |
INDArray |
GaussianReconstructionDistribution.generateAtMean(INDArray preOutDistributionParams) |
INDArray |
ExponentialReconstructionDistribution.generateAtMean(INDArray preOutDistributionParams) |
INDArray |
CompositeReconstructionDistribution.generateAtMean(INDArray preOutDistributionParams) |
INDArray |
BernoulliReconstructionDistribution.generateAtMean(INDArray preOutDistributionParams) |
INDArray |
ReconstructionDistribution.generateRandom(INDArray preOutDistributionParams)
Randomly sample from P(x|z) using the specified distribution parameters
|
INDArray |
LossFunctionWrapper.generateRandom(INDArray preOutDistributionParams) |
INDArray |
GaussianReconstructionDistribution.generateRandom(INDArray preOutDistributionParams) |
INDArray |
ExponentialReconstructionDistribution.generateRandom(INDArray preOutDistributionParams) |
INDArray |
CompositeReconstructionDistribution.generateRandom(INDArray preOutDistributionParams) |
INDArray |
BernoulliReconstructionDistribution.generateRandom(INDArray preOutDistributionParams) |
INDArray |
ReconstructionDistribution.gradient(INDArray x,
INDArray preOutDistributionParams)
Calculate the gradient of the negative log probability with respect to the preOutDistributionParams
|
INDArray |
LossFunctionWrapper.gradient(INDArray x,
INDArray preOutDistributionParams) |
INDArray |
GaussianReconstructionDistribution.gradient(INDArray x,
INDArray preOutDistributionParams) |
INDArray |
ExponentialReconstructionDistribution.gradient(INDArray x,
INDArray preOutDistributionParams) |
INDArray |
CompositeReconstructionDistribution.gradient(INDArray x,
INDArray preOutDistributionParams) |
INDArray |
BernoulliReconstructionDistribution.gradient(INDArray x,
INDArray preOutDistributionParams) |
| Modifier and Type | Method and Description |
|---|---|
INDArray |
CompositeReconstructionDistribution.computeLossFunctionScoreArray(INDArray data,
INDArray reconstruction) |
INDArray |
ReconstructionDistribution.exampleNegLogProbability(INDArray x,
INDArray preOutDistributionParams)
Calculate the negative log probability for each example individually
|
INDArray |
LossFunctionWrapper.exampleNegLogProbability(INDArray x,
INDArray preOutDistributionParams) |
INDArray |
GaussianReconstructionDistribution.exampleNegLogProbability(INDArray x,
INDArray preOutDistributionParams) |
INDArray |
ExponentialReconstructionDistribution.exampleNegLogProbability(INDArray x,
INDArray preOutDistributionParams) |
INDArray |
CompositeReconstructionDistribution.exampleNegLogProbability(INDArray x,
INDArray preOutDistributionParams) |
INDArray |
BernoulliReconstructionDistribution.exampleNegLogProbability(INDArray x,
INDArray preOutDistributionParams) |
INDArray |
ReconstructionDistribution.generateAtMean(INDArray preOutDistributionParams)
Generate a sample from P(x|z), where x = E[P(x|z)]
i.e., return the mean value for the distribution
|
INDArray |
LossFunctionWrapper.generateAtMean(INDArray preOutDistributionParams) |
INDArray |
GaussianReconstructionDistribution.generateAtMean(INDArray preOutDistributionParams) |
INDArray |
ExponentialReconstructionDistribution.generateAtMean(INDArray preOutDistributionParams) |
INDArray |
CompositeReconstructionDistribution.generateAtMean(INDArray preOutDistributionParams) |
INDArray |
BernoulliReconstructionDistribution.generateAtMean(INDArray preOutDistributionParams) |
INDArray |
ReconstructionDistribution.generateRandom(INDArray preOutDistributionParams)
Randomly sample from P(x|z) using the specified distribution parameters
|
INDArray |
LossFunctionWrapper.generateRandom(INDArray preOutDistributionParams) |
INDArray |
GaussianReconstructionDistribution.generateRandom(INDArray preOutDistributionParams) |
INDArray |
ExponentialReconstructionDistribution.generateRandom(INDArray preOutDistributionParams) |
INDArray |
CompositeReconstructionDistribution.generateRandom(INDArray preOutDistributionParams) |
INDArray |
BernoulliReconstructionDistribution.generateRandom(INDArray preOutDistributionParams) |
INDArray |
ReconstructionDistribution.gradient(INDArray x,
INDArray preOutDistributionParams)
Calculate the gradient of the negative log probability with respect to the preOutDistributionParams
|
INDArray |
LossFunctionWrapper.gradient(INDArray x,
INDArray preOutDistributionParams) |
INDArray |
GaussianReconstructionDistribution.gradient(INDArray x,
INDArray preOutDistributionParams) |
INDArray |
ExponentialReconstructionDistribution.gradient(INDArray x,
INDArray preOutDistributionParams) |
INDArray |
CompositeReconstructionDistribution.gradient(INDArray x,
INDArray preOutDistributionParams) |
INDArray |
BernoulliReconstructionDistribution.gradient(INDArray x,
INDArray preOutDistributionParams) |
Layer |
VariationalAutoencoder.instantiate(NeuralNetConfiguration conf,
Collection<TrainingListener> trainingListeners,
int layerIndex,
INDArray layerParamsView,
boolean initializeParams,
DataType networkDataType) |
double |
ReconstructionDistribution.negLogProbability(INDArray x,
INDArray preOutDistributionParams,
boolean average)
Calculate the negative log probability (summed or averaged over each example in the minibatch)
|
double |
LossFunctionWrapper.negLogProbability(INDArray x,
INDArray preOutDistributionParams,
boolean average) |
double |
GaussianReconstructionDistribution.negLogProbability(INDArray x,
INDArray preOutDistributionParams,
boolean average) |
double |
ExponentialReconstructionDistribution.negLogProbability(INDArray x,
INDArray preOutDistributionParams,
boolean average) |
double |
CompositeReconstructionDistribution.negLogProbability(INDArray x,
INDArray preOutDistributionParams,
boolean average) |
double |
BernoulliReconstructionDistribution.negLogProbability(INDArray x,
INDArray preOutDistributionParams,
boolean average) |
| Modifier and Type | Method and Description |
|---|---|
Layer |
OCNNOutputLayer.instantiate(NeuralNetConfiguration conf,
Collection<TrainingListener> trainingListeners,
int layerIndex,
INDArray layerParamsView,
boolean initializeParams,
DataType networkDataType) |
| Modifier and Type | Method and Description |
|---|---|
INDArray |
RnnToFeedForwardPreProcessor.backprop(INDArray output,
int miniBatchSize,
LayerWorkspaceMgr workspaceMgr) |
INDArray |
RnnToCnnPreProcessor.backprop(INDArray output,
int miniBatchSize,
LayerWorkspaceMgr workspaceMgr) |
INDArray |
FeedForwardToRnnPreProcessor.backprop(INDArray output,
int miniBatchSize,
LayerWorkspaceMgr workspaceMgr) |
INDArray |
FeedForwardToCnnPreProcessor.backprop(INDArray epsilons,
int miniBatchSize,
LayerWorkspaceMgr workspaceMgr) |
INDArray |
FeedForwardToCnn3DPreProcessor.backprop(INDArray epsilons,
int miniBatchSize,
LayerWorkspaceMgr workspaceMgr) |
INDArray |
ComposableInputPreProcessor.backprop(INDArray output,
int miniBatchSize,
LayerWorkspaceMgr workspaceMgr) |
INDArray |
CnnToRnnPreProcessor.backprop(INDArray output,
int miniBatchSize,
LayerWorkspaceMgr workspaceMgr) |
INDArray |
CnnToFeedForwardPreProcessor.backprop(INDArray epsilons,
int miniBatchSize,
LayerWorkspaceMgr workspaceMgr) |
INDArray |
Cnn3DToFeedForwardPreProcessor.backprop(INDArray epsilons,
int miniBatchSize,
LayerWorkspaceMgr workspaceMgr) |
INDArray |
RnnToFeedForwardPreProcessor.preProcess(INDArray input,
int miniBatchSize,
LayerWorkspaceMgr workspaceMgr) |
INDArray |
RnnToCnnPreProcessor.preProcess(INDArray input,
int miniBatchSize,
LayerWorkspaceMgr workspaceMgr) |
INDArray |
FeedForwardToRnnPreProcessor.preProcess(INDArray input,
int miniBatchSize,
LayerWorkspaceMgr workspaceMgr) |
INDArray |
FeedForwardToCnnPreProcessor.preProcess(INDArray input,
int miniBatchSize,
LayerWorkspaceMgr workspaceMgr) |
INDArray |
FeedForwardToCnn3DPreProcessor.preProcess(INDArray input,
int miniBatchSize,
LayerWorkspaceMgr workspaceMgr) |
INDArray |
ComposableInputPreProcessor.preProcess(INDArray input,
int miniBatchSize,
LayerWorkspaceMgr workspaceMgr) |
INDArray |
CnnToRnnPreProcessor.preProcess(INDArray input,
int miniBatchSize,
LayerWorkspaceMgr workspaceMgr) |
INDArray |
CnnToFeedForwardPreProcessor.preProcess(INDArray input,
int miniBatchSize,
LayerWorkspaceMgr workspaceMgr) |
INDArray |
Cnn3DToFeedForwardPreProcessor.preProcess(INDArray input,
int miniBatchSize,
LayerWorkspaceMgr workspaceMgr) |
| Modifier and Type | Method and Description |
|---|---|
Pair<INDArray,MaskState> |
RnnToFeedForwardPreProcessor.feedForwardMaskArray(INDArray maskArray,
MaskState currentMaskState,
int minibatchSize) |
Pair<INDArray,MaskState> |
RnnToCnnPreProcessor.feedForwardMaskArray(INDArray maskArray,
MaskState currentMaskState,
int minibatchSize) |
Pair<INDArray,MaskState> |
FeedForwardToRnnPreProcessor.feedForwardMaskArray(INDArray maskArray,
MaskState currentMaskState,
int minibatchSize) |
Pair<INDArray,MaskState> |
FeedForwardToCnnPreProcessor.feedForwardMaskArray(INDArray maskArray,
MaskState currentMaskState,
int minibatchSize) |
Pair<INDArray,MaskState> |
FeedForwardToCnn3DPreProcessor.feedForwardMaskArray(INDArray maskArray,
MaskState currentMaskState,
int minibatchSize) |
Pair<INDArray,MaskState> |
ComposableInputPreProcessor.feedForwardMaskArray(INDArray maskArray,
MaskState currentMaskState,
int minibatchSize) |
Pair<INDArray,MaskState> |
CnnToRnnPreProcessor.feedForwardMaskArray(INDArray maskArray,
MaskState currentMaskState,
int minibatchSize) |
Pair<INDArray,MaskState> |
CnnToFeedForwardPreProcessor.feedForwardMaskArray(INDArray maskArray,
MaskState currentMaskState,
int minibatchSize) |
Pair<INDArray,MaskState> |
Cnn3DToFeedForwardPreProcessor.feedForwardMaskArray(INDArray maskArray,
MaskState currentMaskState,
int minibatchSize) |
Pair<INDArray,MaskState> |
BaseInputPreProcessor.feedForwardMaskArray(INDArray maskArray,
MaskState currentMaskState,
int minibatchSize) |
| Modifier and Type | Method and Description |
|---|---|
INDArray |
RnnToFeedForwardPreProcessor.backprop(INDArray output,
int miniBatchSize,
LayerWorkspaceMgr workspaceMgr) |
INDArray |
RnnToCnnPreProcessor.backprop(INDArray output,
int miniBatchSize,
LayerWorkspaceMgr workspaceMgr) |
INDArray |
FeedForwardToRnnPreProcessor.backprop(INDArray output,
int miniBatchSize,
LayerWorkspaceMgr workspaceMgr) |
INDArray |
FeedForwardToCnnPreProcessor.backprop(INDArray epsilons,
int miniBatchSize,
LayerWorkspaceMgr workspaceMgr) |
INDArray |
FeedForwardToCnn3DPreProcessor.backprop(INDArray epsilons,
int miniBatchSize,
LayerWorkspaceMgr workspaceMgr) |
INDArray |
ComposableInputPreProcessor.backprop(INDArray output,
int miniBatchSize,
LayerWorkspaceMgr workspaceMgr) |
INDArray |
CnnToRnnPreProcessor.backprop(INDArray output,
int miniBatchSize,
LayerWorkspaceMgr workspaceMgr) |
INDArray |
CnnToFeedForwardPreProcessor.backprop(INDArray epsilons,
int miniBatchSize,
LayerWorkspaceMgr workspaceMgr) |
INDArray |
Cnn3DToFeedForwardPreProcessor.backprop(INDArray epsilons,
int miniBatchSize,
LayerWorkspaceMgr workspaceMgr) |
Pair<INDArray,MaskState> |
RnnToFeedForwardPreProcessor.feedForwardMaskArray(INDArray maskArray,
MaskState currentMaskState,
int minibatchSize) |
Pair<INDArray,MaskState> |
RnnToCnnPreProcessor.feedForwardMaskArray(INDArray maskArray,
MaskState currentMaskState,
int minibatchSize) |
Pair<INDArray,MaskState> |
FeedForwardToRnnPreProcessor.feedForwardMaskArray(INDArray maskArray,
MaskState currentMaskState,
int minibatchSize) |
Pair<INDArray,MaskState> |
FeedForwardToCnnPreProcessor.feedForwardMaskArray(INDArray maskArray,
MaskState currentMaskState,
int minibatchSize) |
Pair<INDArray,MaskState> |
FeedForwardToCnn3DPreProcessor.feedForwardMaskArray(INDArray maskArray,
MaskState currentMaskState,
int minibatchSize) |
Pair<INDArray,MaskState> |
ComposableInputPreProcessor.feedForwardMaskArray(INDArray maskArray,
MaskState currentMaskState,
int minibatchSize) |
Pair<INDArray,MaskState> |
CnnToRnnPreProcessor.feedForwardMaskArray(INDArray maskArray,
MaskState currentMaskState,
int minibatchSize) |
Pair<INDArray,MaskState> |
CnnToFeedForwardPreProcessor.feedForwardMaskArray(INDArray maskArray,
MaskState currentMaskState,
int minibatchSize) |
Pair<INDArray,MaskState> |
Cnn3DToFeedForwardPreProcessor.feedForwardMaskArray(INDArray maskArray,
MaskState currentMaskState,
int minibatchSize) |
Pair<INDArray,MaskState> |
BaseInputPreProcessor.feedForwardMaskArray(INDArray maskArray,
MaskState currentMaskState,
int minibatchSize) |
INDArray |
RnnToFeedForwardPreProcessor.preProcess(INDArray input,
int miniBatchSize,
LayerWorkspaceMgr workspaceMgr) |
INDArray |
RnnToCnnPreProcessor.preProcess(INDArray input,
int miniBatchSize,
LayerWorkspaceMgr workspaceMgr) |
INDArray |
FeedForwardToRnnPreProcessor.preProcess(INDArray input,
int miniBatchSize,
LayerWorkspaceMgr workspaceMgr) |
INDArray |
FeedForwardToCnnPreProcessor.preProcess(INDArray input,
int miniBatchSize,
LayerWorkspaceMgr workspaceMgr) |
INDArray |
FeedForwardToCnn3DPreProcessor.preProcess(INDArray input,
int miniBatchSize,
LayerWorkspaceMgr workspaceMgr) |
INDArray |
ComposableInputPreProcessor.preProcess(INDArray input,
int miniBatchSize,
LayerWorkspaceMgr workspaceMgr) |
INDArray |
CnnToRnnPreProcessor.preProcess(INDArray input,
int miniBatchSize,
LayerWorkspaceMgr workspaceMgr) |
INDArray |
CnnToFeedForwardPreProcessor.preProcess(INDArray input,
int miniBatchSize,
LayerWorkspaceMgr workspaceMgr) |
INDArray |
Cnn3DToFeedForwardPreProcessor.preProcess(INDArray input,
int miniBatchSize,
LayerWorkspaceMgr workspaceMgr) |
| Modifier and Type | Method and Description |
|---|---|
INDArray |
WeightNoise.getParameter(Layer layer,
String paramKey,
int iteration,
int epoch,
boolean train,
LayerWorkspaceMgr workspaceMgr) |
INDArray |
IWeightNoise.getParameter(Layer layer,
String paramKey,
int iteration,
int epoch,
boolean train,
LayerWorkspaceMgr workspaceMgr)
Get the parameter, after applying weight noise
|
INDArray |
DropConnect.getParameter(Layer layer,
String paramKey,
int iteration,
int epoch,
boolean train,
LayerWorkspaceMgr workspaceMgr) |
| Modifier and Type | Method and Description |
|---|---|
INDArray |
Gradient.getGradientFor(String variable)
The gradient for the given variable
|
INDArray |
DefaultGradient.getGradientFor(String variable) |
INDArray |
Gradient.gradient()
The full gradient as one flat vector
|
INDArray |
DefaultGradient.gradient() |
INDArray |
Gradient.gradient(List<String> order)
The full gradient as one flat vector
|
INDArray |
DefaultGradient.gradient(List<String> order) |
INDArray |
Gradient.setGradientFor(String variable,
INDArray gradient)
Update gradient for the given variable
|
INDArray |
DefaultGradient.setGradientFor(String variable,
INDArray newGradient) |
INDArray |
Gradient.setGradientFor(String variable,
INDArray gradient,
Character flatteningOrder)
Update gradient for the given variable; also (optionally) specify the order in which the array should be flattened
to a row vector
|
INDArray |
DefaultGradient.setGradientFor(String variable,
INDArray gradient,
Character flatteningOrder) |
| Modifier and Type | Method and Description |
|---|---|
Map<String,INDArray> |
Gradient.gradientForVariable()
Gradient look up table
|
Map<String,INDArray> |
DefaultGradient.gradientForVariable() |
| Modifier and Type | Method and Description |
|---|---|
INDArray |
Gradient.setGradientFor(String variable,
INDArray gradient)
Update gradient for the given variable
|
INDArray |
DefaultGradient.setGradientFor(String variable,
INDArray newGradient) |
INDArray |
Gradient.setGradientFor(String variable,
INDArray gradient,
Character flatteningOrder)
Update gradient for the given variable; also (optionally) specify the order in which the array should be flattened
to a row vector
|
INDArray |
DefaultGradient.setGradientFor(String variable,
INDArray gradient,
Character flatteningOrder) |
| Constructor and Description |
|---|
DefaultGradient(INDArray flattenedGradient) |
| Modifier and Type | Field and Description |
|---|---|
protected INDArray |
ComputationGraph.flattenedGradients |
protected INDArray |
ComputationGraph.flattenedParams |
| Modifier and Type | Method and Description |
|---|---|
INDArray |
ComputationGraph.getGradientsViewArray() |
INDArray |
ComputationGraph.getInput(int inputNum)
Get the previously set input for the ComputationGraph
|
INDArray[] |
ComputationGraph.getInputMaskArrays()
Get the previously set feature/input mask arrays for the ComputationGraph
|
INDArray[] |
ComputationGraph.getInputs()
Get the previously set inputs for the ComputationGraph
|
INDArray[] |
ComputationGraph.getLabelMaskArrays()
Get the previously set label/output mask arrays for the ComputationGraph
|
INDArray |
ComputationGraph.getParam(String paramName) |
INDArray |
ComputationGraph.input() |
INDArray[] |
ComputationGraph.output(boolean train,
boolean clearInputs,
INDArray... input)
An output method for the network, with optional clearing of the layer inputs.
|
INDArray[] |
ComputationGraph.output(boolean train,
INDArray... input)
Return an array of network outputs (predictions), given the specified network inputs
Network outputs are for output layers only.
|
INDArray[] |
ComputationGraph.output(boolean train,
INDArray[] input,
INDArray[] inputMasks)
Return an array of network outputs (predictions), given the specified network inputs
Network outputs are for output layers only.
|
INDArray[] |
ComputationGraph.output(boolean train,
INDArray[] input,
INDArray[] inputMasks,
INDArray[] labelMasks)
Return an array of network outputs (predictions), given the specified network inputs
Network outputs are for output layers only.
|
INDArray[] |
ComputationGraph.output(boolean train,
INDArray[] input,
INDArray[] inputMasks,
INDArray[] labelMasks,
MemoryWorkspace outputWorkspace)
Return an array of network outputs (predictions), given the specified network inputs
Network outputs are for output layers only.
|
INDArray[] |
ComputationGraph.output(boolean train,
MemoryWorkspace outputWorkspace,
INDArray... input)
Return an array of network outputs (predictions), given the specified network inputs
Network outputs are for output layers only.
|
INDArray[] |
ComputationGraph.output(DataSetIterator iterator)
Generate the output for all examples/batches in the input iterator, and concatenate them into a single array
per network output
|
INDArray[] |
ComputationGraph.output(INDArray... input)
Return an array of network outputs (predictions) at test time, given the specified network inputs
Network outputs are for output layers only.
|
INDArray[] |
ComputationGraph.output(List<String> layers,
boolean train,
INDArray[] features,
INDArray[] featureMasks)
Get the activations for the specific layers only
|
INDArray[] |
ComputationGraph.output(MultiDataSetIterator iterator)
Generate the output for all examples/batches in the input iterator, and concatenate them into a single array
per network output
|
protected INDArray[] |
ComputationGraph.outputOfLayersDetached(boolean train,
FwdPassType fwdPassType,
int[] layerIndexes,
INDArray[] features,
INDArray[] fMask,
INDArray[] lMasks,
boolean clearLayerInputs,
boolean detachedInputs,
MemoryWorkspace outputWorkspace)
Provide the output of the specified layers, detached from any workspace.
|
INDArray |
ComputationGraph.outputSingle(boolean train,
boolean clearInputs,
INDArray... input)
Identical to
ComputationGraph.outputSingle(boolean, boolean, INDArray...) but has the option of not clearing the input
arrays (useful when later backpropagating external errors). |
INDArray |
ComputationGraph.outputSingle(boolean train,
INDArray... input)
A convenience method that returns a single INDArray, instead of an INDArray[].
|
INDArray |
ComputationGraph.outputSingle(DataSetIterator iterator)
Generate the output for all examples/batches in the input iterator, and concatenate them into a single array.
|
INDArray |
ComputationGraph.outputSingle(INDArray... input)
A convenience method that returns a single INDArray, instead of an INDArray[].
|
INDArray |
ComputationGraph.outputSingle(MultiDataSetIterator iterator)
Generate the output for all examples/batches in the input iterator, and concatenate them into a single array.
|
INDArray |
ComputationGraph.params() |
INDArray |
ComputationGraph.params(boolean backwardOnly)
Deprecated.
To be removed. Use
ComputationGraph.params() |
INDArray[] |
ComputationGraph.rnnTimeStep(INDArray... inputs)
If this ComputationGraph contains one or more RNN layers: conduct forward pass (prediction)
but using previous stored state for any RNN layers.
|
INDArray[] |
ComputationGraph.rnnTimeStep(MemoryWorkspace outputWorkspace,
INDArray... inputs)
See
ComputationGraph.rnnTimeStep(INDArray...) for details. |
INDArray |
ComputationGraph.scoreExamples(DataSet data,
boolean addRegularizationTerms)
Calculate the score for each example in a DataSet individually.
|
INDArray |
ComputationGraph.scoreExamples(MultiDataSet dataSet,
boolean addRegularizationTerms)
Calculate the score for each example in a DataSet individually.
|
INDArray |
ComputationGraph.updaterState() |
| Modifier and Type | Method and Description |
|---|---|
Map<String,INDArray> |
ComputationGraph.feedForward()
Conduct forward pass using the stored inputs, at test time
|
Map<String,INDArray> |
ComputationGraph.feedForward(boolean train)
Conduct forward pass using the stored inputs
|
Map<String,INDArray> |
ComputationGraph.feedForward(boolean train,
boolean excludeOutputLayers,
boolean includeNonLayerVertexActivations) |
Map<String,INDArray> |
ComputationGraph.feedForward(boolean train,
int layerTillIndex)
Conduct forward pass using the stored inputs
|
Map<String,INDArray> |
ComputationGraph.feedForward(INDArray[] input,
boolean train)
Conduct forward pass using an array of inputs
|
Map<String,INDArray> |
ComputationGraph.feedForward(INDArray[] input,
boolean train,
boolean clearInputs)
Conduct forward pass using an array of inputs.
|
Map<String,INDArray> |
ComputationGraph.feedForward(INDArray[] input,
int layerTillIndex,
boolean train)
Conduct forward pass using an array of inputs
|
Map<String,INDArray> |
ComputationGraph.feedForward(INDArray[] input,
int layerTillIndex,
boolean train,
boolean clearInputs)
Conduct forward pass using an array of inputs.
|
Map<String,INDArray> |
ComputationGraph.feedForward(INDArray input,
boolean train)
Conduct forward pass using a single input array.
|
Map<String,INDArray> |
ComputationGraph.feedForward(INDArray input,
int layerTillIndex,
boolean train)
Conduct forward pass using a single input array.
|
protected Map<String,INDArray> |
ComputationGraph.ffToLayerActivationsDetached(boolean train,
FwdPassType fwdPassType,
boolean storeLastForTBPTT,
int layerIndex,
int[] excludeIdxs,
INDArray[] features,
INDArray[] fMask,
INDArray[] lMask,
boolean clearLayers)
Feed-forward through the network - returning all array activations detached from any workspace.
|
protected Map<String,INDArray> |
ComputationGraph.ffToLayerActivationsInWS(boolean train,
int layerIndex,
int[] excludeIdxs,
FwdPassType fwdPassType,
boolean storeLastForTBPTT,
INDArray[] input,
INDArray[] fMask,
INDArray[] lMask,
boolean clearInputs)
Feed-forward through the network - if workspaces are used, all returned activations will be present in workspace
WS_ALL_LAYERS_ACT.
|
Map<String,INDArray> |
ComputationGraph.paramTable() |
Map<String,INDArray> |
ComputationGraph.paramTable(boolean backpropParamsOnly) |
Map<String,INDArray> |
ComputationGraph.rnnActivateUsingStoredState(INDArray[] inputs,
boolean training,
boolean storeLastForTBPTT)
Similar to rnnTimeStep and feedForward() methods.
|
Map<String,INDArray> |
ComputationGraph.rnnGetPreviousState(int layer)
Get the state of the RNN layer, as used in
ComputationGraph.rnnTimeStep(INDArray...). |
Map<String,INDArray> |
ComputationGraph.rnnGetPreviousState(String layerName)
Get the state of the RNN layer, as used in
ComputationGraph.rnnTimeStep(INDArray...). |
Map<String,Map<String,INDArray>> |
ComputationGraph.rnnGetPreviousStates()
Get a map of states for ALL RNN layers, as used in
ComputationGraph.rnnTimeStep(INDArray...). |
| Modifier and Type | Method and Description |
|---|---|
Gradient |
ComputationGraph.backpropGradient(INDArray... epsilons)
Calculate the gradient of the network with respect to some external errors.
|
protected void |
ComputationGraph.calcBackpropGradients(boolean clearLayers,
boolean truncatedBPTT,
INDArray... externalEpsilons)
Do backprop (gradient calculation)
|
protected void |
ComputationGraph.doTruncatedBPTT(INDArray[] inputs,
INDArray[] labels,
INDArray[] featureMasks,
INDArray[] labelMasks,
LayerWorkspaceMgr workspaceMgr)
Fit the network using truncated BPTT
|
protected void |
ComputationGraph.doTruncatedBPTT(INDArray[] inputs,
INDArray[] labels,
INDArray[] featureMasks,
INDArray[] labelMasks,
LayerWorkspaceMgr workspaceMgr)
Fit the network using truncated BPTT
|
protected void |
ComputationGraph.doTruncatedBPTT(INDArray[] inputs,
INDArray[] labels,
INDArray[] featureMasks,
INDArray[] labelMasks,
LayerWorkspaceMgr workspaceMgr)
Fit the network using truncated BPTT
|
protected void |
ComputationGraph.doTruncatedBPTT(INDArray[] inputs,
INDArray[] labels,
INDArray[] featureMasks,
INDArray[] labelMasks,
LayerWorkspaceMgr workspaceMgr)
Fit the network using truncated BPTT
|
Map<String,INDArray> |
ComputationGraph.feedForward(INDArray[] input,
boolean train)
Conduct forward pass using an array of inputs
|
Map<String,INDArray> |
ComputationGraph.feedForward(INDArray[] input,
boolean train,
boolean clearInputs)
Conduct forward pass using an array of inputs.
|
Map<String,INDArray> |
ComputationGraph.feedForward(INDArray[] input,
int layerTillIndex,
boolean train)
Conduct forward pass using an array of inputs
|
Map<String,INDArray> |
ComputationGraph.feedForward(INDArray[] input,
int layerTillIndex,
boolean train,
boolean clearInputs)
Conduct forward pass using an array of inputs.
|
Map<String,INDArray> |
ComputationGraph.feedForward(INDArray input,
boolean train)
Conduct forward pass using a single input array.
|
Map<String,INDArray> |
ComputationGraph.feedForward(INDArray input,
int layerTillIndex,
boolean train)
Conduct forward pass using a single input array.
|
protected Map<String,INDArray> |
ComputationGraph.ffToLayerActivationsDetached(boolean train,
FwdPassType fwdPassType,
boolean storeLastForTBPTT,
int layerIndex,
int[] excludeIdxs,
INDArray[] features,
INDArray[] fMask,
INDArray[] lMask,
boolean clearLayers)
Feed-forward through the network - returning all array activations detached from any workspace.
|
protected Map<String,INDArray> |
ComputationGraph.ffToLayerActivationsDetached(boolean train,
FwdPassType fwdPassType,
boolean storeLastForTBPTT,
int layerIndex,
int[] excludeIdxs,
INDArray[] features,
INDArray[] fMask,
INDArray[] lMask,
boolean clearLayers)
Feed-forward through the network - returning all array activations detached from any workspace.
|
protected Map<String,INDArray> |
ComputationGraph.ffToLayerActivationsDetached(boolean train,
FwdPassType fwdPassType,
boolean storeLastForTBPTT,
int layerIndex,
int[] excludeIdxs,
INDArray[] features,
INDArray[] fMask,
INDArray[] lMask,
boolean clearLayers)
Feed-forward through the network - returning all array activations detached from any workspace.
|
protected Map<String,INDArray> |
ComputationGraph.ffToLayerActivationsInWS(boolean train,
int layerIndex,
int[] excludeIdxs,
FwdPassType fwdPassType,
boolean storeLastForTBPTT,
INDArray[] input,
INDArray[] fMask,
INDArray[] lMask,
boolean clearInputs)
Feed-forward through the network - if workspaces are used, all returned activations will be present in workspace
WS_ALL_LAYERS_ACT.
|
protected Map<String,INDArray> |
ComputationGraph.ffToLayerActivationsInWS(boolean train,
int layerIndex,
int[] excludeIdxs,
FwdPassType fwdPassType,
boolean storeLastForTBPTT,
INDArray[] input,
INDArray[] fMask,
INDArray[] lMask,
boolean clearInputs)
Feed-forward through the network - if workspaces are used, all returned activations will be present in workspace
WS_ALL_LAYERS_ACT.
|
protected Map<String,INDArray> |
ComputationGraph.ffToLayerActivationsInWS(boolean train,
int layerIndex,
int[] excludeIdxs,
FwdPassType fwdPassType,
boolean storeLastForTBPTT,
INDArray[] input,
INDArray[] fMask,
INDArray[] lMask,
boolean clearInputs)
Feed-forward through the network - if workspaces are used, all returned activations will be present in workspace
WS_ALL_LAYERS_ACT.
|
void |
ComputationGraph.fit(INDArray[] inputs,
INDArray[] labels)
Fit the ComputationGraph given arrays of inputs and labels.
|
void |
ComputationGraph.fit(INDArray[] inputs,
INDArray[] labels)
Fit the ComputationGraph given arrays of inputs and labels.
|
void |
ComputationGraph.fit(INDArray[] inputs,
INDArray[] labels,
INDArray[] featureMaskArrays,
INDArray[] labelMaskArrays)
Fit the ComputationGraph using the specified inputs and labels (and mask arrays)
|
void |
ComputationGraph.fit(INDArray[] inputs,
INDArray[] labels,
INDArray[] featureMaskArrays,
INDArray[] labelMaskArrays)
Fit the ComputationGraph using the specified inputs and labels (and mask arrays)
|
void |
ComputationGraph.fit(INDArray[] inputs,
INDArray[] labels,
INDArray[] featureMaskArrays,
INDArray[] labelMaskArrays)
Fit the ComputationGraph using the specified inputs and labels (and mask arrays)
|
void |
ComputationGraph.fit(INDArray[] inputs,
INDArray[] labels,
INDArray[] featureMaskArrays,
INDArray[] labelMaskArrays)
Fit the ComputationGraph using the specified inputs and labels (and mask arrays)
|
void |
ComputationGraph.fit(INDArray data,
LayerWorkspaceMgr workspaceMgr) |
void |
ComputationGraph.init(INDArray parameters,
boolean cloneParametersArray)
Initialize the ComputationGraph, optionally with an existing parameters array.
|
INDArray[] |
ComputationGraph.output(boolean train,
boolean clearInputs,
INDArray... input)
An output method for the network, with optional clearing of the layer inputs.
|
INDArray[] |
ComputationGraph.output(boolean train,
INDArray... input)
Return an array of network outputs (predictions), given the specified network inputs
Network outputs are for output layers only.
|
INDArray[] |
ComputationGraph.output(boolean train,
INDArray[] input,
INDArray[] inputMasks)
Return an array of network outputs (predictions), given the specified network inputs
Network outputs are for output layers only.
|
INDArray[] |
ComputationGraph.output(boolean train,
INDArray[] input,
INDArray[] inputMasks)
Return an array of network outputs (predictions), given the specified network inputs
Network outputs are for output layers only.
|
INDArray[] |
ComputationGraph.output(boolean train,
INDArray[] input,
INDArray[] inputMasks,
INDArray[] labelMasks)
Return an array of network outputs (predictions), given the specified network inputs
Network outputs are for output layers only.
|
INDArray[] |
ComputationGraph.output(boolean train,
INDArray[] input,
INDArray[] inputMasks,
INDArray[] labelMasks)
Return an array of network outputs (predictions), given the specified network inputs
Network outputs are for output layers only.
|
INDArray[] |
ComputationGraph.output(boolean train,
INDArray[] input,
INDArray[] inputMasks,
INDArray[] labelMasks)
Return an array of network outputs (predictions), given the specified network inputs
Network outputs are for output layers only.
|
INDArray[] |
ComputationGraph.output(boolean train,
INDArray[] input,
INDArray[] inputMasks,
INDArray[] labelMasks,
MemoryWorkspace outputWorkspace)
Return an array of network outputs (predictions), given the specified network inputs
Network outputs are for output layers only.
|
INDArray[] |
ComputationGraph.output(boolean train,
INDArray[] input,
INDArray[] inputMasks,
INDArray[] labelMasks,
MemoryWorkspace outputWorkspace)
Return an array of network outputs (predictions), given the specified network inputs
Network outputs are for output layers only.
|
INDArray[] |
ComputationGraph.output(boolean train,
INDArray[] input,
INDArray[] inputMasks,
INDArray[] labelMasks,
MemoryWorkspace outputWorkspace)
Return an array of network outputs (predictions), given the specified network inputs
Network outputs are for output layers only.
|
INDArray[] |
ComputationGraph.output(boolean train,
MemoryWorkspace outputWorkspace,
INDArray... input)
Return an array of network outputs (predictions), given the specified network inputs
Network outputs are for output layers only.
|
INDArray[] |
ComputationGraph.output(INDArray... input)
Return an array of network outputs (predictions) at test time, given the specified network inputs
Network outputs are for output layers only.
|
<T> T |
ComputationGraph.output(INDArray[] inputs,
INDArray[] inputMasks,
INDArray[] labelMasks,
OutputAdapter<T> outputAdapter)
This method uses provided OutputAdapter to return custom object built from INDArray
PLEASE NOTE: This method uses dedicated Workspace for output generation to avoid redundant allocations
|
<T> T |
ComputationGraph.output(INDArray[] inputs,
INDArray[] inputMasks,
INDArray[] labelMasks,
OutputAdapter<T> outputAdapter)
This method uses provided OutputAdapter to return custom object built from INDArray
PLEASE NOTE: This method uses dedicated Workspace for output generation to avoid redundant allocations
|
<T> T |
ComputationGraph.output(INDArray[] inputs,
INDArray[] inputMasks,
INDArray[] labelMasks,
OutputAdapter<T> outputAdapter)
This method uses provided OutputAdapter to return custom object built from INDArray
PLEASE NOTE: This method uses dedicated Workspace for output generation to avoid redundant allocations
|
INDArray[] |
ComputationGraph.output(List<String> layers,
boolean train,
INDArray[] features,
INDArray[] featureMasks)
Get the activations for the specific layers only
|
INDArray[] |
ComputationGraph.output(List<String> layers,
boolean train,
INDArray[] features,
INDArray[] featureMasks)
Get the activations for the specific layers only
|
protected INDArray[] |
ComputationGraph.outputOfLayersDetached(boolean train,
FwdPassType fwdPassType,
int[] layerIndexes,
INDArray[] features,
INDArray[] fMask,
INDArray[] lMasks,
boolean clearLayerInputs,
boolean detachedInputs,
MemoryWorkspace outputWorkspace)
Provide the output of the specified layers, detached from any workspace.
|
protected INDArray[] |
ComputationGraph.outputOfLayersDetached(boolean train,
FwdPassType fwdPassType,
int[] layerIndexes,
INDArray[] features,
INDArray[] fMask,
INDArray[] lMasks,
boolean clearLayerInputs,
boolean detachedInputs,
MemoryWorkspace outputWorkspace)
Provide the output of the specified layers, detached from any workspace.
|
protected INDArray[] |
ComputationGraph.outputOfLayersDetached(boolean train,
FwdPassType fwdPassType,
int[] layerIndexes,
INDArray[] features,
INDArray[] fMask,
INDArray[] lMasks,
boolean clearLayerInputs,
boolean detachedInputs,
MemoryWorkspace outputWorkspace)
Provide the output of the specified layers, detached from any workspace.
|
INDArray |
ComputationGraph.outputSingle(boolean train,
boolean clearInputs,
INDArray... input)
Identical to
ComputationGraph.outputSingle(boolean, boolean, INDArray...) but has the option of not clearing the input
arrays (useful when later backpropagating external errors). |
INDArray |
ComputationGraph.outputSingle(boolean train,
INDArray... input)
A convenience method that returns a single INDArray, instead of an INDArray[].
|
INDArray |
ComputationGraph.outputSingle(INDArray... input)
A convenience method that returns a single INDArray, instead of an INDArray[].
|
Map<String,INDArray> |
ComputationGraph.rnnActivateUsingStoredState(INDArray[] inputs,
boolean training,
boolean storeLastForTBPTT)
Similar to rnnTimeStep and feedForward() methods.
|
INDArray[] |
ComputationGraph.rnnTimeStep(INDArray... inputs)
If this ComputationGraph contains one or more RNN layers: conduct forward pass (prediction)
but using previous stored state for any RNN layers.
|
INDArray[] |
ComputationGraph.rnnTimeStep(MemoryWorkspace outputWorkspace,
INDArray... inputs)
See
ComputationGraph.rnnTimeStep(INDArray...) for details. |
void |
ComputationGraph.setBackpropGradientsViewArray(INDArray gradient) |
void |
ComputationGraph.setInput(int inputNum,
INDArray input)
Set the specified input for the ComputationGraph
|
void |
ComputationGraph.setInputs(INDArray... inputs)
Set all inputs for the ComputationGraph network
|
void |
ComputationGraph.setLabel(int labelNum,
INDArray label)
Set the specified label for the ComputationGraph
|
void |
ComputationGraph.setLabels(INDArray... labels)
Set all labels for the ComputationGraph network
|
void |
ComputationGraph.setLayerMaskArrays(INDArray[] featureMaskArrays,
INDArray[] labelMaskArrays)
Set the mask arrays for features and labels.
|
void |
ComputationGraph.setLayerMaskArrays(INDArray[] featureMaskArrays,
INDArray[] labelMaskArrays)
Set the mask arrays for features and labels.
|
void |
ComputationGraph.setParam(String key,
INDArray val) |
void |
ComputationGraph.setParams(INDArray params) |
void |
ComputationGraph.setParamsViewArray(INDArray gradient) |
void |
ComputationGraph.update(INDArray gradient,
String paramType) |
protected void |
ComputationGraph.validateArrayWorkspaces(LayerWorkspaceMgr mgr,
INDArray array,
ArrayType arrayType,
String vertexName,
boolean isInputVertex,
String op) |
| Modifier and Type | Method and Description |
|---|---|
void |
ComputationGraph.rnnSetPreviousState(int layer,
Map<String,INDArray> state)
Set the state of the RNN layer, for use in
ComputationGraph.rnnTimeStep(INDArray...) |
void |
ComputationGraph.rnnSetPreviousState(String layerName,
Map<String,INDArray> state)
Set the state of the RNN layer, for use in
ComputationGraph.rnnTimeStep(INDArray...) |
void |
ComputationGraph.rnnSetPreviousStates(Map<String,Map<String,INDArray>> previousStates)
Set the states for all RNN layers, for use in
ComputationGraph.rnnTimeStep(INDArray...) |
void |
ComputationGraph.setParamTable(Map<String,INDArray> paramTable) |
| Modifier and Type | Field and Description |
|---|---|
protected INDArray |
BaseGraphVertex.epsilon |
protected INDArray[] |
BaseGraphVertex.inputs |
| Modifier and Type | Method and Description |
|---|---|
INDArray |
GraphVertex.doForward(boolean training,
LayerWorkspaceMgr workspaceMgr)
Do forward pass using the stored inputs
|
INDArray |
BaseWrapperVertex.doForward(boolean training,
LayerWorkspaceMgr workspaceMgr) |
INDArray |
GraphVertex.getEpsilon()
Get the epsilon/error (i.e., dL/dOutput) array previously set for this GraphVertex
|
INDArray |
BaseWrapperVertex.getEpsilon() |
INDArray |
BaseGraphVertex.getEpsilon() |
INDArray |
BaseWrapperVertex.getGradientsViewArray() |
INDArray |
BaseGraphVertex.getGradientsViewArray() |
INDArray[] |
GraphVertex.getInputs()
Get the array of inputs previously set for this GraphVertex
|
INDArray[] |
BaseWrapperVertex.getInputs() |
INDArray |
BaseWrapperVertex.params() |
INDArray |
BaseGraphVertex.params() |
| Modifier and Type | Method and Description |
|---|---|
Pair<INDArray,MaskState> |
GraphVertex.feedForwardMaskArrays(INDArray[] maskArrays,
MaskState currentMaskState,
int minibatchSize) |
Pair<INDArray,MaskState> |
BaseWrapperVertex.feedForwardMaskArrays(INDArray[] maskArrays,
MaskState currentMaskState,
int minibatchSize) |
Map<String,INDArray> |
GraphVertex.paramTable(boolean backpropOnly)
Get the parameter table for the vertex
|
Map<String,INDArray> |
BaseWrapperVertex.paramTable(boolean backpropOnly) |
Map<String,INDArray> |
BaseGraphVertex.paramTable(boolean backpropOnly) |
| Modifier and Type | Method and Description |
|---|---|
Pair<INDArray,MaskState> |
GraphVertex.feedForwardMaskArrays(INDArray[] maskArrays,
MaskState currentMaskState,
int minibatchSize) |
Pair<INDArray,MaskState> |
BaseWrapperVertex.feedForwardMaskArrays(INDArray[] maskArrays,
MaskState currentMaskState,
int minibatchSize) |
void |
GraphVertex.setBackpropGradientsViewArray(INDArray backpropGradientsViewArray)
|
void |
BaseWrapperVertex.setBackpropGradientsViewArray(INDArray backpropGradientsViewArray) |
void |
GraphVertex.setEpsilon(INDArray epsilon)
Set the errors (epsilon - aka dL/dActivation) for this GraphVertex
|
void |
BaseWrapperVertex.setEpsilon(INDArray epsilon) |
void |
BaseGraphVertex.setEpsilon(INDArray epsilon) |
void |
GraphVertex.setInput(int inputNumber,
INDArray input,
LayerWorkspaceMgr workspaceMgr)
Set the input activations.
|
void |
BaseWrapperVertex.setInput(int inputNumber,
INDArray input,
LayerWorkspaceMgr workspaceMgr) |
void |
BaseGraphVertex.setInput(int inputNumber,
INDArray input,
LayerWorkspaceMgr workspaceMgr) |
void |
GraphVertex.setInputs(INDArray... inputs)
Set all inputs for this GraphVertex
|
void |
BaseWrapperVertex.setInputs(INDArray... inputs) |
| Modifier and Type | Method and Description |
|---|---|
INDArray |
LayerVertex.computeScoreForExamples(double r,
LayerWorkspaceMgr workspaceMgr) |
INDArray |
UnstackVertex.doForward(boolean training,
LayerWorkspaceMgr workspaceMgr) |
INDArray |
SubsetVertex.doForward(boolean training,
LayerWorkspaceMgr workspaceMgr) |
INDArray |
StackVertex.doForward(boolean training,
LayerWorkspaceMgr workspaceMgr) |
INDArray |
ShiftVertex.doForward(boolean training,
LayerWorkspaceMgr workspaceMgr) |
INDArray |
ScaleVertex.doForward(boolean training,
LayerWorkspaceMgr workspaceMgr) |
INDArray |
ReshapeVertex.doForward(boolean training,
LayerWorkspaceMgr workspaceMgr) |
INDArray |
PreprocessorVertex.doForward(boolean training,
LayerWorkspaceMgr workspaceMgr) |
INDArray |
PoolHelperVertex.doForward(boolean training,
LayerWorkspaceMgr workspaceMgr) |
INDArray |
MergeVertex.doForward(boolean training,
LayerWorkspaceMgr workspaceMgr) |
INDArray |
LayerVertex.doForward(boolean training,
LayerWorkspaceMgr workspaceMgr) |
INDArray |
L2Vertex.doForward(boolean training,
LayerWorkspaceMgr workspaceMgr) |
INDArray |
L2NormalizeVertex.doForward(boolean training,
LayerWorkspaceMgr workspaceMgr) |
INDArray |
InputVertex.doForward(boolean training,
LayerWorkspaceMgr workspaceMgr) |
INDArray |
ElementWiseVertex.doForward(boolean training,
LayerWorkspaceMgr workspaceMgr) |
INDArray |
LayerVertex.getGradientsViewArray() |
INDArray |
LayerVertex.params() |
| Modifier and Type | Method and Description |
|---|---|
Pair<INDArray,MaskState> |
UnstackVertex.feedForwardMaskArrays(INDArray[] maskArrays,
MaskState currentMaskState,
int minibatchSize) |
Pair<INDArray,MaskState> |
SubsetVertex.feedForwardMaskArrays(INDArray[] maskArrays,
MaskState currentMaskState,
int minibatchSize) |
Pair<INDArray,MaskState> |
StackVertex.feedForwardMaskArrays(INDArray[] maskArrays,
MaskState currentMaskState,
int minibatchSize) |
Pair<INDArray,MaskState> |
ShiftVertex.feedForwardMaskArrays(INDArray[] maskArrays,
MaskState currentMaskState,
int minibatchSize) |
Pair<INDArray,MaskState> |
ScaleVertex.feedForwardMaskArrays(INDArray[] maskArrays,
MaskState currentMaskState,
int minibatchSize) |
Pair<INDArray,MaskState> |
ReshapeVertex.feedForwardMaskArrays(INDArray[] maskArrays,
MaskState currentMaskState,
int minibatchSize) |
Pair<INDArray,MaskState> |
PreprocessorVertex.feedForwardMaskArrays(INDArray[] maskArrays,
MaskState currentMaskState,
int minibatchSize) |
Pair<INDArray,MaskState> |
PoolHelperVertex.feedForwardMaskArrays(INDArray[] maskArrays,
MaskState currentMaskState,
int minibatchSize) |
Pair<INDArray,MaskState> |
MergeVertex.feedForwardMaskArrays(INDArray[] maskArrays,
MaskState currentMaskState,
int minibatchSize) |
Pair<INDArray,MaskState> |
LayerVertex.feedForwardMaskArrays(INDArray[] maskArrays,
MaskState currentMaskState,
int minibatchSize) |
Pair<INDArray,MaskState> |
L2Vertex.feedForwardMaskArrays(INDArray[] maskArrays,
MaskState currentMaskState,
int minibatchSize) |
Pair<INDArray,MaskState> |
L2NormalizeVertex.feedForwardMaskArrays(INDArray[] maskArrays,
MaskState currentMaskState,
int minibatchSize) |
Pair<INDArray,MaskState> |
InputVertex.feedForwardMaskArrays(INDArray[] maskArrays,
MaskState currentMaskState,
int minibatchSize) |
Pair<INDArray,MaskState> |
ElementWiseVertex.feedForwardMaskArrays(INDArray[] maskArrays,
MaskState currentMaskState,
int minibatchSize) |
Map<String,INDArray> |
LayerVertex.paramTable(boolean backpropOnly) |
| Modifier and Type | Method and Description |
|---|---|
Pair<INDArray,MaskState> |
UnstackVertex.feedForwardMaskArrays(INDArray[] maskArrays,
MaskState currentMaskState,
int minibatchSize) |
Pair<INDArray,MaskState> |
SubsetVertex.feedForwardMaskArrays(INDArray[] maskArrays,
MaskState currentMaskState,
int minibatchSize) |
Pair<INDArray,MaskState> |
StackVertex.feedForwardMaskArrays(INDArray[] maskArrays,
MaskState currentMaskState,
int minibatchSize) |
Pair<INDArray,MaskState> |
ShiftVertex.feedForwardMaskArrays(INDArray[] maskArrays,
MaskState currentMaskState,
int minibatchSize) |
Pair<INDArray,MaskState> |
ScaleVertex.feedForwardMaskArrays(INDArray[] maskArrays,
MaskState currentMaskState,
int minibatchSize) |
Pair<INDArray,MaskState> |
ReshapeVertex.feedForwardMaskArrays(INDArray[] maskArrays,
MaskState currentMaskState,
int minibatchSize) |
Pair<INDArray,MaskState> |
PreprocessorVertex.feedForwardMaskArrays(INDArray[] maskArrays,
MaskState currentMaskState,
int minibatchSize) |
Pair<INDArray,MaskState> |
PoolHelperVertex.feedForwardMaskArrays(INDArray[] maskArrays,
MaskState currentMaskState,
int minibatchSize) |
Pair<INDArray,MaskState> |
MergeVertex.feedForwardMaskArrays(INDArray[] maskArrays,
MaskState currentMaskState,
int minibatchSize) |
Pair<INDArray,MaskState> |
LayerVertex.feedForwardMaskArrays(INDArray[] maskArrays,
MaskState currentMaskState,
int minibatchSize) |
Pair<INDArray,MaskState> |
L2Vertex.feedForwardMaskArrays(INDArray[] maskArrays,
MaskState currentMaskState,
int minibatchSize) |
Pair<INDArray,MaskState> |
L2NormalizeVertex.feedForwardMaskArrays(INDArray[] maskArrays,
MaskState currentMaskState,
int minibatchSize) |
Pair<INDArray,MaskState> |
InputVertex.feedForwardMaskArrays(INDArray[] maskArrays,
MaskState currentMaskState,
int minibatchSize) |
Pair<INDArray,MaskState> |
ElementWiseVertex.feedForwardMaskArrays(INDArray[] maskArrays,
MaskState currentMaskState,
int minibatchSize) |
void |
UnstackVertex.setBackpropGradientsViewArray(INDArray backpropGradientsViewArray) |
void |
SubsetVertex.setBackpropGradientsViewArray(INDArray backpropGradientsViewArray) |
void |
StackVertex.setBackpropGradientsViewArray(INDArray backpropGradientsViewArray) |
void |
ShiftVertex.setBackpropGradientsViewArray(INDArray backpropGradientsViewArray) |
void |
ScaleVertex.setBackpropGradientsViewArray(INDArray backpropGradientsViewArray) |
void |
ReshapeVertex.setBackpropGradientsViewArray(INDArray backpropGradientsViewArray) |
void |
PreprocessorVertex.setBackpropGradientsViewArray(INDArray backpropGradientsViewArray) |
void |
PoolHelperVertex.setBackpropGradientsViewArray(INDArray backpropGradientsViewArray) |
void |
MergeVertex.setBackpropGradientsViewArray(INDArray backpropGradientsViewArray) |
void |
LayerVertex.setBackpropGradientsViewArray(INDArray backpropGradientsViewArray) |
void |
L2Vertex.setBackpropGradientsViewArray(INDArray backpropGradientsViewArray) |
void |
L2NormalizeVertex.setBackpropGradientsViewArray(INDArray backpropGradientsViewArray) |
void |
InputVertex.setBackpropGradientsViewArray(INDArray backpropGradientsViewArray) |
void |
ElementWiseVertex.setBackpropGradientsViewArray(INDArray backpropGradientsViewArray) |
void |
LayerVertex.setInput(int inputNumber,
INDArray input,
LayerWorkspaceMgr workspaceMgr) |
| Modifier and Type | Method and Description |
|---|---|
INDArray |
ReverseTimeSeriesVertex.doForward(boolean training,
LayerWorkspaceMgr workspaceMgr) |
INDArray |
LastTimeStepVertex.doForward(boolean training,
LayerWorkspaceMgr workspaceMgr) |
INDArray |
DuplicateToTimeSeriesVertex.doForward(boolean training,
LayerWorkspaceMgr workspaceMgr) |
| Modifier and Type | Method and Description |
|---|---|
Pair<INDArray,MaskState> |
ReverseTimeSeriesVertex.feedForwardMaskArrays(INDArray[] maskArrays,
MaskState currentMaskState,
int minibatchSize) |
Pair<INDArray,MaskState> |
LastTimeStepVertex.feedForwardMaskArrays(INDArray[] maskArrays,
MaskState currentMaskState,
int minibatchSize) |
Pair<INDArray,MaskState> |
DuplicateToTimeSeriesVertex.feedForwardMaskArrays(INDArray[] maskArrays,
MaskState currentMaskState,
int minibatchSize) |
| Modifier and Type | Method and Description |
|---|---|
Pair<INDArray,MaskState> |
ReverseTimeSeriesVertex.feedForwardMaskArrays(INDArray[] maskArrays,
MaskState currentMaskState,
int minibatchSize) |
Pair<INDArray,MaskState> |
LastTimeStepVertex.feedForwardMaskArrays(INDArray[] maskArrays,
MaskState currentMaskState,
int minibatchSize) |
Pair<INDArray,MaskState> |
DuplicateToTimeSeriesVertex.feedForwardMaskArrays(INDArray[] maskArrays,
MaskState currentMaskState,
int minibatchSize) |
void |
ReverseTimeSeriesVertex.setBackpropGradientsViewArray(INDArray backpropGradientsViewArray) |
void |
LastTimeStepVertex.setBackpropGradientsViewArray(INDArray backpropGradientsViewArray) |
void |
DuplicateToTimeSeriesVertex.setBackpropGradientsViewArray(INDArray backpropGradientsViewArray) |
| Modifier and Type | Field and Description |
|---|---|
protected INDArray |
BaseLayer.gradientsFlattened |
protected INDArray |
AbstractLayer.input |
protected INDArray |
BaseOutputLayer.inputMaskArray |
protected INDArray |
LossLayer.labels |
protected INDArray |
BaseOutputLayer.labels |
protected INDArray |
AbstractLayer.maskArray |
protected INDArray |
BaseLayer.paramsFlattened |
protected INDArray |
AbstractLayer.preOutput |
| Modifier and Type | Field and Description |
|---|---|
protected Map<String,INDArray> |
BaseLayer.gradientViews |
protected Map<String,INDArray> |
BaseLayer.params |
protected Map<String,INDArray> |
BaseLayer.weightNoiseParams |
| Modifier and Type | Method and Description |
|---|---|
INDArray |
RepeatVector.activate(boolean training,
LayerWorkspaceMgr workspaceMgr) |
INDArray |
LossLayer.activate(boolean training,
LayerWorkspaceMgr workspaceMgr) |
INDArray |
FrozenLayerWithBackprop.activate(boolean training,
LayerWorkspaceMgr workspaceMgr) |
INDArray |
FrozenLayer.activate(boolean training,
LayerWorkspaceMgr workspaceMgr) |
INDArray |
DropoutLayer.activate(boolean training,
LayerWorkspaceMgr workspaceMgr) |
INDArray |
BaseLayer.activate(boolean training,
LayerWorkspaceMgr workspaceMgr) |
INDArray |
ActivationLayer.activate(boolean training,
LayerWorkspaceMgr mgr) |
INDArray |
LossLayer.activate(INDArray input,
boolean training,
LayerWorkspaceMgr workspaceMgr) |
INDArray |
FrozenLayerWithBackprop.activate(INDArray input,
boolean training,
LayerWorkspaceMgr workspaceMgr) |
INDArray |
FrozenLayer.activate(INDArray input,
boolean training,
LayerWorkspaceMgr workspaceMgr) |
INDArray |
BaseOutputLayer.activate(INDArray input,
boolean training,
LayerWorkspaceMgr workspaceMgr) |
INDArray |
AbstractLayer.activate(INDArray input,
boolean training,
LayerWorkspaceMgr workspaceMgr) |
protected INDArray |
AbstractLayer.backpropDropOutIfPresent(INDArray epsilon) |
INDArray |
LossLayer.computeScoreForExamples(double fullNetRegTerm,
LayerWorkspaceMgr workspaceMgr)
Compute the score for each example individually, after labels and input have been set.
|
INDArray |
BaseOutputLayer.computeScoreForExamples(double fullNetRegTerm,
LayerWorkspaceMgr workspaceMgr)
Compute the score for each example individually, after labels and input have been set.
|
INDArray |
BasePretrainNetwork.getCorruptedInput(INDArray x,
double corruptionLevel)
Corrupts the given input by doing a binomial sampling
given the corruption level
|
INDArray |
BaseLayer.getGradientsViewArray() |
INDArray |
AbstractLayer.getGradientsViewArray() |
INDArray |
AbstractLayer.getInput() |
INDArray |
LossLayer.getLabels() |
INDArray |
BaseOutputLayer.getLabels() |
protected INDArray |
LossLayer.getLabels2d() |
protected INDArray |
OutputLayer.getLabels2d(LayerWorkspaceMgr workspaceMgr,
ArrayType arrayType) |
protected abstract INDArray |
BaseOutputLayer.getLabels2d(LayerWorkspaceMgr workspaceMgr,
ArrayType arrayType) |
INDArray |
AbstractLayer.getMaskArray() |
INDArray |
RepeatVector.getParam(String param) |
INDArray |
BaseLayer.getParam(String param) |
INDArray |
AbstractLayer.getParam(String param) |
protected INDArray |
BaseLayer.getParamWithNoise(String param,
boolean training,
LayerWorkspaceMgr workspaceMgr)
Get the parameter, after applying any weight noise (such as DropConnect) if necessary.
|
INDArray |
AbstractLayer.input() |
INDArray |
RepeatVector.params() |
INDArray |
LossLayer.params() |
INDArray |
DropoutLayer.params() |
INDArray |
BasePretrainNetwork.params() |
INDArray |
BaseLayer.params()
Returns the parameters of the neural network as a flattened row vector
|
INDArray |
ActivationLayer.params() |
INDArray |
AbstractLayer.params()
Returns the parameters of the neural network as a flattened row vector
|
protected INDArray |
RepeatVector.preOutput(boolean training,
boolean forBackprop,
LayerWorkspaceMgr workspaceMgr) |
protected INDArray |
BaseLayer.preOutput(boolean training,
LayerWorkspaceMgr workspaceMgr) |
protected INDArray |
BaseOutputLayer.preOutput2d(boolean training,
LayerWorkspaceMgr workspaceMgr) |
| Modifier and Type | Method and Description |
|---|---|
Pair<Gradient,INDArray> |
RepeatVector.backpropGradient(INDArray epsilon,
LayerWorkspaceMgr workspaceMgr) |
Pair<Gradient,INDArray> |
LossLayer.backpropGradient(INDArray epsilon,
LayerWorkspaceMgr workspaceMgr) |
Pair<Gradient,INDArray> |
FrozenLayerWithBackprop.backpropGradient(INDArray epsilon,
LayerWorkspaceMgr workspaceMgr) |
Pair<Gradient,INDArray> |
FrozenLayer.backpropGradient(INDArray epsilon,
LayerWorkspaceMgr workspaceMgr) |
Pair<Gradient,INDArray> |
DropoutLayer.backpropGradient(INDArray epsilon,
LayerWorkspaceMgr workspaceMgr) |
Pair<Gradient,INDArray> |
BasePretrainNetwork.backpropGradient(INDArray epsilon,
LayerWorkspaceMgr workspaceMgr) |
Pair<Gradient,INDArray> |
BaseOutputLayer.backpropGradient(INDArray epsilon,
LayerWorkspaceMgr workspaceMgr) |
Pair<Gradient,INDArray> |
BaseLayer.backpropGradient(INDArray epsilon,
LayerWorkspaceMgr workspaceMgr) |
Pair<Gradient,INDArray> |
ActivationLayer.backpropGradient(INDArray epsilon,
LayerWorkspaceMgr workspaceMgr) |
Pair<INDArray,MaskState> |
AbstractLayer.feedForwardMaskArray(INDArray maskArray,
MaskState currentMaskState,
int minibatchSize) |
Map<String,INDArray> |
BaseLayer.paramTable() |
Map<String,INDArray> |
AbstractLayer.paramTable() |
Map<String,INDArray> |
BasePretrainNetwork.paramTable(boolean backpropParamsOnly) |
Map<String,INDArray> |
BaseLayer.paramTable(boolean backpropParamsOnly) |
Map<String,INDArray> |
AbstractLayer.paramTable(boolean backpropParamsOnly) |
protected Pair<INDArray,INDArray> |
BaseLayer.preOutputWithPreNorm(boolean training,
boolean forBackprop,
LayerWorkspaceMgr workspaceMgr) |
protected Pair<INDArray,INDArray> |
BaseLayer.preOutputWithPreNorm(boolean training,
boolean forBackprop,
LayerWorkspaceMgr workspaceMgr) |
abstract Pair<INDArray,INDArray> |
BasePretrainNetwork.sampleHiddenGivenVisible(INDArray v)
Sample the hidden distribution given the visible
|
abstract Pair<INDArray,INDArray> |
BasePretrainNetwork.sampleHiddenGivenVisible(INDArray v)
Sample the hidden distribution given the visible
|
abstract Pair<INDArray,INDArray> |
BasePretrainNetwork.sampleVisibleGivenHidden(INDArray h)
Sample the visible distribution given the hidden
|
abstract Pair<INDArray,INDArray> |
BasePretrainNetwork.sampleVisibleGivenHidden(INDArray h)
Sample the visible distribution given the hidden
|
| Modifier and Type | Method and Description |
|---|---|
INDArray |
LossLayer.activate(INDArray input,
boolean training,
LayerWorkspaceMgr workspaceMgr) |
INDArray |
FrozenLayerWithBackprop.activate(INDArray input,
boolean training,
LayerWorkspaceMgr workspaceMgr) |
INDArray |
FrozenLayer.activate(INDArray input,
boolean training,
LayerWorkspaceMgr workspaceMgr) |
INDArray |
BaseOutputLayer.activate(INDArray input,
boolean training,
LayerWorkspaceMgr workspaceMgr) |
INDArray |
AbstractLayer.activate(INDArray input,
boolean training,
LayerWorkspaceMgr workspaceMgr) |
protected void |
BaseOutputLayer.applyMask(INDArray to) |
protected void |
AbstractLayer.applyMask(INDArray to) |
protected INDArray |
AbstractLayer.backpropDropOutIfPresent(INDArray epsilon) |
Pair<Gradient,INDArray> |
RepeatVector.backpropGradient(INDArray epsilon,
LayerWorkspaceMgr workspaceMgr) |
Pair<Gradient,INDArray> |
LossLayer.backpropGradient(INDArray epsilon,
LayerWorkspaceMgr workspaceMgr) |
Pair<Gradient,INDArray> |
FrozenLayerWithBackprop.backpropGradient(INDArray epsilon,
LayerWorkspaceMgr workspaceMgr) |
Pair<Gradient,INDArray> |
FrozenLayer.backpropGradient(INDArray epsilon,
LayerWorkspaceMgr workspaceMgr) |
Pair<Gradient,INDArray> |
DropoutLayer.backpropGradient(INDArray epsilon,
LayerWorkspaceMgr workspaceMgr) |
Pair<Gradient,INDArray> |
BasePretrainNetwork.backpropGradient(INDArray epsilon,
LayerWorkspaceMgr workspaceMgr) |
Pair<Gradient,INDArray> |
BaseOutputLayer.backpropGradient(INDArray epsilon,
LayerWorkspaceMgr workspaceMgr) |
Pair<Gradient,INDArray> |
BaseLayer.backpropGradient(INDArray epsilon,
LayerWorkspaceMgr workspaceMgr) |
Pair<Gradient,INDArray> |
ActivationLayer.backpropGradient(INDArray epsilon,
LayerWorkspaceMgr workspaceMgr) |
protected Gradient |
BasePretrainNetwork.createGradient(INDArray wGradient,
INDArray vBiasGradient,
INDArray hBiasGradient) |
double |
LossLayer.f1Score(INDArray examples,
INDArray labels)
Returns the f1 score for the given examples.
|
double |
BaseOutputLayer.f1Score(INDArray examples,
INDArray labels)
Returns the f1 score for the given examples.
|
Pair<INDArray,MaskState> |
AbstractLayer.feedForwardMaskArray(INDArray maskArray,
MaskState currentMaskState,
int minibatchSize) |
void |
LossLayer.fit(INDArray input,
INDArray labels)
Fit the model
|
void |
BaseOutputLayer.fit(INDArray input,
INDArray labels)
Fit the model
|
void |
LossLayer.fit(INDArray examples,
int[] labels)
Fit the model
|
void |
BaseOutputLayer.fit(INDArray examples,
int[] labels)
Fit the model
|
void |
RepeatVector.fit(INDArray input,
LayerWorkspaceMgr workspaceMgr) |
void |
LossLayer.fit(INDArray input,
LayerWorkspaceMgr workspaceMgr) |
void |
FrozenLayerWithBackprop.fit(INDArray data,
LayerWorkspaceMgr workspaceMgr) |
void |
FrozenLayer.fit(INDArray data,
LayerWorkspaceMgr workspaceMgr) |
void |
DropoutLayer.fit(INDArray input,
LayerWorkspaceMgr workspaceMgr) |
void |
BaseOutputLayer.fit(INDArray data,
LayerWorkspaceMgr workspaceMgr) |
void |
BaseLayer.fit(INDArray input,
LayerWorkspaceMgr workspaceMgr) |
void |
AbstractLayer.fit(INDArray input,
LayerWorkspaceMgr workspaceMgr) |
INDArray |
BasePretrainNetwork.getCorruptedInput(INDArray x,
double corruptionLevel)
Corrupts the given input by doing a binomial sampling
given the corruption level
|
int[] |
LossLayer.predict(INDArray input)
Returns the predictions for each example in the dataset
|
int[] |
BaseOutputLayer.predict(INDArray input)
Returns the predictions for each example in the dataset
|
abstract Pair<INDArray,INDArray> |
BasePretrainNetwork.sampleHiddenGivenVisible(INDArray v)
Sample the hidden distribution given the visible
|
abstract Pair<INDArray,INDArray> |
BasePretrainNetwork.sampleVisibleGivenHidden(INDArray h)
Sample the visible distribution given the hidden
|
void |
FrozenLayerWithBackprop.setBackpropGradientsViewArray(INDArray gradients) |
void |
FrozenLayer.setBackpropGradientsViewArray(INDArray gradients) |
void |
BaseLayer.setBackpropGradientsViewArray(INDArray gradients) |
void |
AbstractLayer.setBackpropGradientsViewArray(INDArray gradients) |
void |
AbstractLayer.setInput(INDArray input,
LayerWorkspaceMgr workspaceMgr) |
void |
LossLayer.setLabels(INDArray labels) |
void |
BaseOutputLayer.setLabels(INDArray labels) |
void |
AbstractLayer.setMaskArray(INDArray maskArray) |
void |
BaseLayer.setParam(String key,
INDArray val) |
void |
AbstractLayer.setParam(String key,
INDArray val) |
void |
RepeatVector.setParams(INDArray params) |
void |
BasePretrainNetwork.setParams(INDArray params) |
void |
BaseLayer.setParams(INDArray params) |
void |
AbstractLayer.setParams(INDArray params) |
protected void |
BaseLayer.setParams(INDArray params,
char order) |
protected void |
AbstractLayer.setParams(INDArray params,
char order) |
void |
BaseLayer.setParamsViewArray(INDArray params) |
void |
AbstractLayer.setParamsViewArray(INDArray params) |
protected void |
LossLayer.setScoreWithZ(INDArray z) |
protected void |
BasePretrainNetwork.setScoreWithZ(INDArray z) |
protected void |
BaseOutputLayer.setScoreWithZ(INDArray z) |
protected void |
BaseLayer.setScoreWithZ(INDArray z) |
void |
RepeatVector.update(INDArray gradient,
String paramType) |
void |
FrozenLayerWithBackprop.update(INDArray gradient,
String paramType) |
void |
FrozenLayer.update(INDArray gradient,
String paramType) |
void |
BaseLayer.update(INDArray gradient,
String paramType) |
void |
AbstractLayer.update(INDArray gradient,
String paramType) |
| Modifier and Type | Method and Description |
|---|---|
void |
BaseLayer.setParamTable(Map<String,INDArray> paramTable) |
void |
AbstractLayer.setParamTable(Map<String,INDArray> paramTable) |
| Modifier and Type | Field and Description |
|---|---|
protected INDArray |
ConvolutionLayer.dummyBias |
protected INDArray |
ConvolutionLayer.dummyBiasGrad |
protected INDArray |
ConvolutionLayer.i2d |
protected INDArray |
CnnLossLayer.labels |
protected INDArray |
Cnn3DLossLayer.labels |
| Modifier and Type | Method and Description |
|---|---|
INDArray |
ZeroPaddingLayer.activate(boolean training,
LayerWorkspaceMgr workspaceMgr) |
INDArray |
ZeroPadding3DLayer.activate(boolean training,
LayerWorkspaceMgr workspaceMgr) |
INDArray |
ZeroPadding1DLayer.activate(boolean training,
LayerWorkspaceMgr workspaceMgr) |
INDArray |
SpaceToDepth.activate(boolean training,
LayerWorkspaceMgr workspaceMgr) |
INDArray |
SpaceToBatch.activate(boolean training,
LayerWorkspaceMgr workspaceMgr) |
INDArray |
SeparableConvolution2DLayer.activate(boolean training,
LayerWorkspaceMgr workspaceMgr) |
INDArray |
DepthwiseConvolution2DLayer.activate(boolean training,
LayerWorkspaceMgr workspaceMgr) |
INDArray |
Deconvolution2DLayer.activate(boolean training,
LayerWorkspaceMgr workspaceMgr) |
INDArray |
Cropping3DLayer.activate(boolean training,
LayerWorkspaceMgr workspaceMgr) |
INDArray |
Cropping2DLayer.activate(boolean training,
LayerWorkspaceMgr workspaceMgr) |
INDArray |
Cropping1DLayer.activate(boolean training,
LayerWorkspaceMgr workspaceMgr) |
INDArray |
ConvolutionLayer.activate(boolean training,
LayerWorkspaceMgr workspaceMgr) |
INDArray |
Convolution1DLayer.activate(boolean training,
LayerWorkspaceMgr workspaceMgr) |
INDArray |
CnnLossLayer.activate(boolean training,
LayerWorkspaceMgr workspaceMgr) |
INDArray |
Cnn3DLossLayer.activate(boolean training,
LayerWorkspaceMgr workspaceMgr) |
INDArray |
ConvolutionHelper.activate(INDArray z,
IActivation afn,
boolean training) |
INDArray |
CnnLossLayer.computeScoreForExamples(double fullNetRegTerm,
LayerWorkspaceMgr workspaceMgr)
Compute the score for each example individually, after labels and input have been set.
|
INDArray |
Cnn3DLossLayer.computeScoreForExamples(double fullNetRegTerm,
LayerWorkspaceMgr workspaceMgr)
Compute the score for each example individually, after labels and input have been set.
|
INDArray |
SpaceToDepth.getParam(String param) |
INDArray |
SpaceToBatch.getParam(String param) |
INDArray |
SpaceToDepth.params() |
INDArray |
SpaceToBatch.params() |
protected INDArray |
SpaceToDepth.preOutput(boolean training,
boolean forBackprop,
LayerWorkspaceMgr workspaceMgr) |
protected INDArray |
SpaceToBatch.preOutput(boolean training,
boolean forBackprop,
LayerWorkspaceMgr workspaceMgr) |
INDArray |
Convolution3DLayer.preOutput(boolean training,
LayerWorkspaceMgr workspaceMgr) |
INDArray |
ConvolutionHelper.preOutput(INDArray input,
INDArray weights,
INDArray bias,
int[] kernel,
int[] strides,
int[] pad,
ConvolutionLayer.AlgoMode mode,
ConvolutionLayer.FwdAlgo fwdAlgo,
ConvolutionMode convolutionMode,
int[] dilation,
LayerWorkspaceMgr workspaceMgr) |
| Modifier and Type | Method and Description |
|---|---|
Pair<Gradient,INDArray> |
ConvolutionHelper.backpropGradient(INDArray input,
INDArray weights,
INDArray bias,
INDArray delta,
int[] kernel,
int[] strides,
int[] pad,
INDArray biasGradView,
INDArray weightGradView,
IActivation afn,
ConvolutionLayer.AlgoMode mode,
ConvolutionLayer.BwdFilterAlgo bwdFilterAlgo,
ConvolutionLayer.BwdDataAlgo bwdDataAlgo,
ConvolutionMode convolutionMode,
int[] dilation,
LayerWorkspaceMgr workspaceMgr) |
Pair<Gradient,INDArray> |
ZeroPaddingLayer.backpropGradient(INDArray epsilon,
LayerWorkspaceMgr workspaceMgr) |
Pair<Gradient,INDArray> |
ZeroPadding3DLayer.backpropGradient(INDArray epsilon,
LayerWorkspaceMgr workspaceMgr) |
Pair<Gradient,INDArray> |
ZeroPadding1DLayer.backpropGradient(INDArray epsilon,
LayerWorkspaceMgr workspaceMgr) |
Pair<Gradient,INDArray> |
SpaceToDepth.backpropGradient(INDArray epsilon,
LayerWorkspaceMgr workspaceMgr) |
Pair<Gradient,INDArray> |
SpaceToBatch.backpropGradient(INDArray epsilon,
LayerWorkspaceMgr workspaceMgr) |
Pair<Gradient,INDArray> |
SeparableConvolution2DLayer.backpropGradient(INDArray epsilon,
LayerWorkspaceMgr workspaceMgr) |
Pair<Gradient,INDArray> |
DepthwiseConvolution2DLayer.backpropGradient(INDArray epsilon,
LayerWorkspaceMgr workspaceMgr) |
Pair<Gradient,INDArray> |
Deconvolution2DLayer.backpropGradient(INDArray epsilon,
LayerWorkspaceMgr workspaceMgr) |
Pair<Gradient,INDArray> |
Cropping3DLayer.backpropGradient(INDArray epsilon,
LayerWorkspaceMgr workspaceMgr) |
Pair<Gradient,INDArray> |
Cropping2DLayer.backpropGradient(INDArray epsilon,
LayerWorkspaceMgr workspaceMgr) |
Pair<Gradient,INDArray> |
Cropping1DLayer.backpropGradient(INDArray epsilon,
LayerWorkspaceMgr workspaceMgr) |
Pair<Gradient,INDArray> |
ConvolutionLayer.backpropGradient(INDArray epsilon,
LayerWorkspaceMgr workspaceMgr) |
Pair<Gradient,INDArray> |
Convolution3DLayer.backpropGradient(INDArray epsilon,
LayerWorkspaceMgr workspaceMgr) |
Pair<Gradient,INDArray> |
Convolution1DLayer.backpropGradient(INDArray epsilon,
LayerWorkspaceMgr workspaceMgr) |
Pair<Gradient,INDArray> |
CnnLossLayer.backpropGradient(INDArray epsilon,
LayerWorkspaceMgr workspaceMgr) |
Pair<Gradient,INDArray> |
Cnn3DLossLayer.backpropGradient(INDArray epsilon,
LayerWorkspaceMgr workspaceMgr) |
protected Pair<INDArray,INDArray> |
Convolution1DLayer.causalConv1dForward() |
protected Pair<INDArray,INDArray> |
Convolution1DLayer.causalConv1dForward() |
Pair<INDArray,MaskState> |
ConvolutionLayer.feedForwardMaskArray(INDArray maskArray,
MaskState currentMaskState,
int minibatchSize) |
Pair<INDArray,MaskState> |
Convolution1DLayer.feedForwardMaskArray(INDArray maskArray,
MaskState currentMaskState,
int minibatchSize) |
Pair<INDArray,MaskState> |
CnnLossLayer.feedForwardMaskArray(INDArray maskArray,
MaskState currentMaskState,
int minibatchSize) |
Pair<INDArray,MaskState> |
Cnn3DLossLayer.feedForwardMaskArray(INDArray maskArray,
MaskState currentMaskState,
int minibatchSize) |
protected Pair<INDArray,INDArray> |
SeparableConvolution2DLayer.preOutput(boolean training,
boolean forBackprop,
LayerWorkspaceMgr workspaceMgr) |
protected Pair<INDArray,INDArray> |
SeparableConvolution2DLayer.preOutput(boolean training,
boolean forBackprop,
LayerWorkspaceMgr workspaceMgr) |
protected Pair<INDArray,INDArray> |
DepthwiseConvolution2DLayer.preOutput(boolean training,
boolean forBackprop,
LayerWorkspaceMgr workspaceMgr) |
protected Pair<INDArray,INDArray> |
DepthwiseConvolution2DLayer.preOutput(boolean training,
boolean forBackprop,
LayerWorkspaceMgr workspaceMgr) |
protected Pair<INDArray,INDArray> |
Deconvolution2DLayer.preOutput(boolean training,
boolean forBackprop,
LayerWorkspaceMgr workspaceMgr) |
protected Pair<INDArray,INDArray> |
Deconvolution2DLayer.preOutput(boolean training,
boolean forBackprop,
LayerWorkspaceMgr workspaceMgr) |
protected Pair<INDArray,INDArray> |
ConvolutionLayer.preOutput(boolean training,
boolean forBackprop,
LayerWorkspaceMgr workspaceMgr)
PreOutput method that also returns the im2col2d array (if being called for backprop), as this can be re-used
instead of being calculated again.
|
protected Pair<INDArray,INDArray> |
ConvolutionLayer.preOutput(boolean training,
boolean forBackprop,
LayerWorkspaceMgr workspaceMgr)
PreOutput method that also returns the im2col2d array (if being called for backprop), as this can be re-used
instead of being calculated again.
|
protected Pair<INDArray,INDArray> |
Convolution3DLayer.preOutput(boolean training,
boolean forBackprop,
LayerWorkspaceMgr workspaceMgr) |
protected Pair<INDArray,INDArray> |
Convolution3DLayer.preOutput(boolean training,
boolean forBackprop,
LayerWorkspaceMgr workspaceMgr) |
protected Pair<INDArray,INDArray> |
Convolution1DLayer.preOutput(boolean training,
boolean forBackprop,
LayerWorkspaceMgr workspaceMgr) |
protected Pair<INDArray,INDArray> |
Convolution1DLayer.preOutput(boolean training,
boolean forBackprop,
LayerWorkspaceMgr workspaceMgr) |
protected Pair<INDArray,INDArray> |
ConvolutionLayer.preOutput4d(boolean training,
boolean forBackprop,
LayerWorkspaceMgr workspaceMgr)
preOutput4d: Used so that ConvolutionLayer subclasses (such as Convolution1DLayer) can maintain their standard
non-4d preOutput method, while overriding this to return 4d activations (for use in backprop) without modifying
the public API
|
protected Pair<INDArray,INDArray> |
ConvolutionLayer.preOutput4d(boolean training,
boolean forBackprop,
LayerWorkspaceMgr workspaceMgr)
preOutput4d: Used so that ConvolutionLayer subclasses (such as Convolution1DLayer) can maintain their standard
non-4d preOutput method, while overriding this to return 4d activations (for use in backprop) without modifying
the public API
|
protected Pair<INDArray,INDArray> |
Convolution1DLayer.preOutput4d(boolean training,
boolean forBackprop,
LayerWorkspaceMgr workspaceMgr) |
protected Pair<INDArray,INDArray> |
Convolution1DLayer.preOutput4d(boolean training,
boolean forBackprop,
LayerWorkspaceMgr workspaceMgr) |
| Modifier and Type | Method and Description |
|---|---|
INDArray |
ConvolutionHelper.activate(INDArray z,
IActivation afn,
boolean training) |
Pair<Gradient,INDArray> |
ConvolutionHelper.backpropGradient(INDArray input,
INDArray weights,
INDArray bias,
INDArray delta,
int[] kernel,
int[] strides,
int[] pad,
INDArray biasGradView,
INDArray weightGradView,
IActivation afn,
ConvolutionLayer.AlgoMode mode,
ConvolutionLayer.BwdFilterAlgo bwdFilterAlgo,
ConvolutionLayer.BwdDataAlgo bwdDataAlgo,
ConvolutionMode convolutionMode,
int[] dilation,
LayerWorkspaceMgr workspaceMgr) |
Pair<Gradient,INDArray> |
ZeroPaddingLayer.backpropGradient(INDArray epsilon,
LayerWorkspaceMgr workspaceMgr) |
Pair<Gradient,INDArray> |
ZeroPadding3DLayer.backpropGradient(INDArray epsilon,
LayerWorkspaceMgr workspaceMgr) |
Pair<Gradient,INDArray> |
ZeroPadding1DLayer.backpropGradient(INDArray epsilon,
LayerWorkspaceMgr workspaceMgr) |
Pair<Gradient,INDArray> |
SpaceToDepth.backpropGradient(INDArray epsilon,
LayerWorkspaceMgr workspaceMgr) |
Pair<Gradient,INDArray> |
SpaceToBatch.backpropGradient(INDArray epsilon,
LayerWorkspaceMgr workspaceMgr) |
Pair<Gradient,INDArray> |
SeparableConvolution2DLayer.backpropGradient(INDArray epsilon,
LayerWorkspaceMgr workspaceMgr) |
Pair<Gradient,INDArray> |
DepthwiseConvolution2DLayer.backpropGradient(INDArray epsilon,
LayerWorkspaceMgr workspaceMgr) |
Pair<Gradient,INDArray> |
Deconvolution2DLayer.backpropGradient(INDArray epsilon,
LayerWorkspaceMgr workspaceMgr) |
Pair<Gradient,INDArray> |
Cropping3DLayer.backpropGradient(INDArray epsilon,
LayerWorkspaceMgr workspaceMgr) |
Pair<Gradient,INDArray> |
Cropping2DLayer.backpropGradient(INDArray epsilon,
LayerWorkspaceMgr workspaceMgr) |
Pair<Gradient,INDArray> |
Cropping1DLayer.backpropGradient(INDArray epsilon,
LayerWorkspaceMgr workspaceMgr) |
Pair<Gradient,INDArray> |
ConvolutionLayer.backpropGradient(INDArray epsilon,
LayerWorkspaceMgr workspaceMgr) |
Pair<Gradient,INDArray> |
Convolution3DLayer.backpropGradient(INDArray epsilon,
LayerWorkspaceMgr workspaceMgr) |
Pair<Gradient,INDArray> |
Convolution1DLayer.backpropGradient(INDArray epsilon,
LayerWorkspaceMgr workspaceMgr) |
Pair<Gradient,INDArray> |
CnnLossLayer.backpropGradient(INDArray epsilon,
LayerWorkspaceMgr workspaceMgr) |
Pair<Gradient,INDArray> |
Cnn3DLossLayer.backpropGradient(INDArray epsilon,
LayerWorkspaceMgr workspaceMgr) |
double |
CnnLossLayer.f1Score(INDArray examples,
INDArray labels)
Returns the f1 score for the given examples.
|
double |
Cnn3DLossLayer.f1Score(INDArray examples,
INDArray labels)
Returns the f1 score for the given examples.
|
Pair<INDArray,MaskState> |
ConvolutionLayer.feedForwardMaskArray(INDArray maskArray,
MaskState currentMaskState,
int minibatchSize) |
Pair<INDArray,MaskState> |
Convolution1DLayer.feedForwardMaskArray(INDArray maskArray,
MaskState currentMaskState,
int minibatchSize) |
Pair<INDArray,MaskState> |
CnnLossLayer.feedForwardMaskArray(INDArray maskArray,
MaskState currentMaskState,
int minibatchSize) |
Pair<INDArray,MaskState> |
Cnn3DLossLayer.feedForwardMaskArray(INDArray maskArray,
MaskState currentMaskState,
int minibatchSize) |
void |
CnnLossLayer.fit(INDArray examples,
INDArray labels) |
void |
Cnn3DLossLayer.fit(INDArray examples,
INDArray labels) |
void |
CnnLossLayer.fit(INDArray examples,
int[] labels) |
void |
Cnn3DLossLayer.fit(INDArray examples,
int[] labels) |
void |
ConvolutionLayer.fit(INDArray input,
LayerWorkspaceMgr workspaceMgr) |
int[] |
CnnLossLayer.predict(INDArray examples) |
int[] |
Cnn3DLossLayer.predict(INDArray examples) |
INDArray |
ConvolutionHelper.preOutput(INDArray input,
INDArray weights,
INDArray bias,
int[] kernel,
int[] strides,
int[] pad,
ConvolutionLayer.AlgoMode mode,
ConvolutionLayer.FwdAlgo fwdAlgo,
ConvolutionMode convolutionMode,
int[] dilation,
LayerWorkspaceMgr workspaceMgr) |
void |
CnnLossLayer.setMaskArray(INDArray maskArray) |
void |
Cnn3DLossLayer.setMaskArray(INDArray maskArray) |
void |
SpaceToDepth.setParams(INDArray params) |
void |
SpaceToBatch.setParams(INDArray params) |
void |
ConvolutionLayer.setParams(INDArray params) |
void |
SpaceToDepth.update(INDArray gradient,
String paramType) |
void |
SpaceToBatch.update(INDArray gradient,
String paramType) |
| Modifier and Type | Method and Description |
|---|---|
INDArray |
SubsamplingLayer.activate(boolean training,
LayerWorkspaceMgr workspaceMgr) |
INDArray |
Subsampling3DLayer.activate(boolean training,
LayerWorkspaceMgr workspaceMgr) |
INDArray |
Subsampling1DLayer.activate(boolean training,
LayerWorkspaceMgr workspaceMgr) |
INDArray |
SubsamplingHelper.activate(INDArray input,
boolean training,
int[] kernel,
int[] strides,
int[] pad,
PoolingType poolingType,
ConvolutionMode convolutionMode,
int[] dilation,
LayerWorkspaceMgr workspaceMgr) |
INDArray |
SubsamplingLayer.getParam(String param) |
INDArray |
Subsampling3DLayer.getParam(String param) |
INDArray |
SubsamplingLayer.params() |
INDArray |
Subsampling3DLayer.params() |
| Modifier and Type | Method and Description |
|---|---|
Pair<Gradient,INDArray> |
SubsamplingHelper.backpropGradient(INDArray input,
INDArray epsilon,
int[] kernel,
int[] strides,
int[] pad,
PoolingType poolingType,
ConvolutionMode convolutionMode,
int[] dilation,
LayerWorkspaceMgr workspaceMgr) |
Pair<Gradient,INDArray> |
SubsamplingLayer.backpropGradient(INDArray epsilon,
LayerWorkspaceMgr workspaceMgr) |
Pair<Gradient,INDArray> |
Subsampling3DLayer.backpropGradient(INDArray epsilon,
LayerWorkspaceMgr workspaceMgr) |
Pair<Gradient,INDArray> |
Subsampling1DLayer.backpropGradient(INDArray epsilon,
LayerWorkspaceMgr workspaceMgr) |
Pair<INDArray,MaskState> |
SubsamplingLayer.feedForwardMaskArray(INDArray maskArray,
MaskState currentMaskState,
int minibatchSize) |
Pair<INDArray,MaskState> |
Subsampling1DLayer.feedForwardMaskArray(INDArray maskArray,
MaskState currentMaskState,
int minibatchSize) |
| Modifier and Type | Method and Description |
|---|---|
INDArray |
SubsamplingHelper.activate(INDArray input,
boolean training,
int[] kernel,
int[] strides,
int[] pad,
PoolingType poolingType,
ConvolutionMode convolutionMode,
int[] dilation,
LayerWorkspaceMgr workspaceMgr) |
Pair<Gradient,INDArray> |
SubsamplingHelper.backpropGradient(INDArray input,
INDArray epsilon,
int[] kernel,
int[] strides,
int[] pad,
PoolingType poolingType,
ConvolutionMode convolutionMode,
int[] dilation,
LayerWorkspaceMgr workspaceMgr) |
Pair<Gradient,INDArray> |
SubsamplingLayer.backpropGradient(INDArray epsilon,
LayerWorkspaceMgr workspaceMgr) |
Pair<Gradient,INDArray> |
Subsampling3DLayer.backpropGradient(INDArray epsilon,
LayerWorkspaceMgr workspaceMgr) |
Pair<Gradient,INDArray> |
Subsampling1DLayer.backpropGradient(INDArray epsilon,
LayerWorkspaceMgr workspaceMgr) |
Pair<INDArray,MaskState> |
SubsamplingLayer.feedForwardMaskArray(INDArray maskArray,
MaskState currentMaskState,
int minibatchSize) |
Pair<INDArray,MaskState> |
Subsampling1DLayer.feedForwardMaskArray(INDArray maskArray,
MaskState currentMaskState,
int minibatchSize) |
void |
SubsamplingLayer.fit(INDArray input,
LayerWorkspaceMgr workspaceMgr) |
void |
Subsampling3DLayer.fit(INDArray input,
LayerWorkspaceMgr workspaceMgr) |
void |
SubsamplingLayer.setParams(INDArray params) |
void |
Subsampling3DLayer.setParams(INDArray params) |
void |
SubsamplingLayer.update(INDArray gradient,
String paramType) |
void |
Subsampling3DLayer.update(INDArray gradient,
String paramType) |
| Modifier and Type | Method and Description |
|---|---|
INDArray |
Upsampling3D.activate(boolean training,
LayerWorkspaceMgr workspaceMgr) |
INDArray |
Upsampling2D.activate(boolean training,
LayerWorkspaceMgr workspaceMgr) |
INDArray |
Upsampling1D.activate(boolean training,
LayerWorkspaceMgr workspaceMgr) |
INDArray |
Upsampling3D.getParam(String param) |
INDArray |
Upsampling2D.getParam(String param) |
INDArray |
Upsampling3D.params() |
INDArray |
Upsampling2D.params() |
protected INDArray |
Upsampling3D.preOutput(boolean training,
boolean forBackprop,
LayerWorkspaceMgr workspaceMgr) |
protected INDArray |
Upsampling2D.preOutput(boolean training,
boolean forBackprop,
LayerWorkspaceMgr workspaceMgr) |
protected INDArray |
Upsampling1D.preOutput(boolean training,
boolean forBackprop,
LayerWorkspaceMgr workspaceMgr) |
| Modifier and Type | Method and Description |
|---|---|
Pair<Gradient,INDArray> |
Upsampling3D.backpropGradient(INDArray epsilon,
LayerWorkspaceMgr workspaceMgr) |
Pair<Gradient,INDArray> |
Upsampling2D.backpropGradient(INDArray epsilon,
LayerWorkspaceMgr workspaceMgr) |
Pair<Gradient,INDArray> |
Upsampling1D.backpropGradient(INDArray epsilon,
LayerWorkspaceMgr workspaceMgr) |
| Modifier and Type | Method and Description |
|---|---|
Pair<Gradient,INDArray> |
Upsampling3D.backpropGradient(INDArray epsilon,
LayerWorkspaceMgr workspaceMgr) |
Pair<Gradient,INDArray> |
Upsampling2D.backpropGradient(INDArray epsilon,
LayerWorkspaceMgr workspaceMgr) |
Pair<Gradient,INDArray> |
Upsampling1D.backpropGradient(INDArray epsilon,
LayerWorkspaceMgr workspaceMgr) |
void |
Upsampling3D.fit(INDArray input,
LayerWorkspaceMgr workspaceMgr) |
void |
Upsampling2D.fit(INDArray input,
LayerWorkspaceMgr workspaceMgr) |
void |
Upsampling3D.setParams(INDArray params) |
void |
Upsampling2D.setParams(INDArray params) |
void |
Upsampling3D.update(INDArray gradient,
String paramType) |
void |
Upsampling2D.update(INDArray gradient,
String paramType) |
| Modifier and Type | Method and Description |
|---|---|
INDArray |
PReLU.activate(boolean training,
LayerWorkspaceMgr mgr) |
| Modifier and Type | Method and Description |
|---|---|
Pair<Gradient,INDArray> |
PReLU.backpropGradient(INDArray epsilon,
LayerWorkspaceMgr workspaceMgr) |
| Modifier and Type | Method and Description |
|---|---|
Pair<Gradient,INDArray> |
PReLU.backpropGradient(INDArray epsilon,
LayerWorkspaceMgr workspaceMgr) |
| Modifier and Type | Method and Description |
|---|---|
INDArray |
AutoEncoder.activate(boolean training,
LayerWorkspaceMgr workspaceMgr) |
INDArray |
AutoEncoder.activate(INDArray input,
boolean training,
LayerWorkspaceMgr workspaceMgr) |
INDArray |
AutoEncoder.decode(INDArray y,
LayerWorkspaceMgr workspaceMgr) |
INDArray |
AutoEncoder.encode(INDArray v,
boolean training,
LayerWorkspaceMgr workspaceMgr) |
| Modifier and Type | Method and Description |
|---|---|
Pair<INDArray,INDArray> |
AutoEncoder.sampleHiddenGivenVisible(INDArray v) |
Pair<INDArray,INDArray> |
AutoEncoder.sampleHiddenGivenVisible(INDArray v) |
Pair<INDArray,INDArray> |
AutoEncoder.sampleVisibleGivenHidden(INDArray h) |
Pair<INDArray,INDArray> |
AutoEncoder.sampleVisibleGivenHidden(INDArray h) |
| Modifier and Type | Method and Description |
|---|---|
INDArray |
AutoEncoder.activate(INDArray input,
boolean training,
LayerWorkspaceMgr workspaceMgr) |
INDArray |
AutoEncoder.decode(INDArray y,
LayerWorkspaceMgr workspaceMgr) |
INDArray |
AutoEncoder.encode(INDArray v,
boolean training,
LayerWorkspaceMgr workspaceMgr) |
Pair<INDArray,INDArray> |
AutoEncoder.sampleHiddenGivenVisible(INDArray v) |
Pair<INDArray,INDArray> |
AutoEncoder.sampleVisibleGivenHidden(INDArray h) |
| Modifier and Type | Method and Description |
|---|---|
INDArray |
Tree.prediction() |
INDArray |
Tree.vector() |
| Modifier and Type | Method and Description |
|---|---|
void |
Tree.setPrediction(INDArray prediction) |
void |
Tree.setVector(INDArray vector) |
| Modifier and Type | Method and Description |
|---|---|
void |
DenseLayer.fit(INDArray input,
LayerWorkspaceMgr workspaceMgr) |
| Modifier and Type | Method and Description |
|---|---|
INDArray |
ElementWiseMultiplicationLayer.preOutput(boolean training,
LayerWorkspaceMgr workspaceMgr) |
| Modifier and Type | Method and Description |
|---|---|
Pair<Gradient,INDArray> |
ElementWiseMultiplicationLayer.backpropGradient(INDArray epsilon,
LayerWorkspaceMgr workspaceMgr) |
| Modifier and Type | Method and Description |
|---|---|
Pair<Gradient,INDArray> |
ElementWiseMultiplicationLayer.backpropGradient(INDArray epsilon,
LayerWorkspaceMgr workspaceMgr) |
| Modifier and Type | Method and Description |
|---|---|
INDArray |
EmbeddingSequenceLayer.activate(boolean training,
LayerWorkspaceMgr workspaceMgr) |
INDArray |
EmbeddingLayer.activate(boolean training,
LayerWorkspaceMgr workspaceMgr) |
protected INDArray |
EmbeddingSequenceLayer.preOutput(boolean training,
LayerWorkspaceMgr workspaceMgr) |
protected INDArray |
EmbeddingLayer.preOutput(boolean training,
LayerWorkspaceMgr workspaceMgr) |
| Modifier and Type | Method and Description |
|---|---|
Pair<Gradient,INDArray> |
EmbeddingSequenceLayer.backpropGradient(INDArray epsilon,
LayerWorkspaceMgr workspaceMgr) |
Pair<Gradient,INDArray> |
EmbeddingLayer.backpropGradient(INDArray epsilon,
LayerWorkspaceMgr workspaceMgr) |
| Modifier and Type | Method and Description |
|---|---|
Pair<Gradient,INDArray> |
EmbeddingSequenceLayer.backpropGradient(INDArray epsilon,
LayerWorkspaceMgr workspaceMgr) |
Pair<Gradient,INDArray> |
EmbeddingLayer.backpropGradient(INDArray epsilon,
LayerWorkspaceMgr workspaceMgr) |
| Modifier and Type | Method and Description |
|---|---|
INDArray |
MKLDNNLocalResponseNormalizationHelper.activate(INDArray x,
boolean training,
double k,
double n,
double alpha,
double beta,
LayerWorkspaceMgr workspaceMgr) |
INDArray |
MKLDNNSubsamplingHelper.activate(INDArray input,
boolean training,
int[] kernel,
int[] strides,
int[] pad,
PoolingType poolingType,
ConvolutionMode convolutionMode,
int[] dilation,
LayerWorkspaceMgr workspaceMgr) |
INDArray |
MKLDNNConvHelper.activate(INDArray z,
IActivation afn,
boolean training) |
INDArray |
MKLDNNBatchNormHelper.getMeanCache(DataType dataType) |
INDArray |
MKLDNNBatchNormHelper.getVarCache(DataType dataType) |
INDArray |
MKLDNNBatchNormHelper.preOutput(INDArray x,
boolean training,
long[] shape,
INDArray gamma,
INDArray beta,
INDArray mean,
INDArray var,
double decay,
double eps,
LayerWorkspaceMgr workspaceMgr) |
INDArray |
MKLDNNConvHelper.preOutput(INDArray input,
INDArray weights,
INDArray bias,
int[] kernel,
int[] strides,
int[] pad,
ConvolutionLayer.AlgoMode mode,
ConvolutionLayer.FwdAlgo fwdAlgo,
ConvolutionMode convolutionMode,
int[] dilation,
LayerWorkspaceMgr workspaceMgr) |
| Modifier and Type | Method and Description |
|---|---|
Pair<Gradient,INDArray> |
MKLDNNLocalResponseNormalizationHelper.backpropGradient(INDArray input,
INDArray epsilon,
double k,
double n,
double alpha,
double beta,
LayerWorkspaceMgr workspaceMgr) |
Pair<Gradient,INDArray> |
MKLDNNConvHelper.backpropGradient(INDArray input,
INDArray weights,
INDArray bias,
INDArray delta,
int[] kernel,
int[] strides,
int[] pad,
INDArray biasGradView,
INDArray weightGradView,
IActivation afn,
ConvolutionLayer.AlgoMode mode,
ConvolutionLayer.BwdFilterAlgo bwdFilterAlgo,
ConvolutionLayer.BwdDataAlgo bwdDataAlgo,
ConvolutionMode convolutionMode,
int[] dilation,
LayerWorkspaceMgr workspaceMgr) |
Pair<Gradient,INDArray> |
MKLDNNSubsamplingHelper.backpropGradient(INDArray input,
INDArray epsilon,
int[] kernel,
int[] strides,
int[] pad,
PoolingType poolingType,
ConvolutionMode convolutionMode,
int[] dilation,
LayerWorkspaceMgr workspaceMgr) |
Pair<Gradient,INDArray> |
MKLDNNBatchNormHelper.backpropGradient(INDArray input,
INDArray epsilon,
long[] shape,
INDArray gamma,
INDArray beta,
INDArray dGammaView,
INDArray dBetaView,
double eps,
LayerWorkspaceMgr workspaceMgr) |
Pair<Gradient,INDArray> |
MKLDNNLSTMHelper.backpropGradient(NeuralNetConfiguration conf,
IActivation gateActivationFn,
INDArray input,
INDArray recurrentWeights,
INDArray inputWeights,
INDArray epsilon,
boolean truncatedBPTT,
int tbpttBackwardLength,
FwdPassReturn fwdPass,
boolean forwards,
String inputWeightKey,
String recurrentWeightKey,
String biasWeightKey,
Map<String,INDArray> gradientViews,
INDArray maskArray,
boolean hasPeepholeConnections,
LayerWorkspaceMgr workspaceMgr) |
| Modifier and Type | Method and Description |
|---|---|
INDArray |
MKLDNNLocalResponseNormalizationHelper.activate(INDArray x,
boolean training,
double k,
double n,
double alpha,
double beta,
LayerWorkspaceMgr workspaceMgr) |
INDArray |
MKLDNNSubsamplingHelper.activate(INDArray input,
boolean training,
int[] kernel,
int[] strides,
int[] pad,
PoolingType poolingType,
ConvolutionMode convolutionMode,
int[] dilation,
LayerWorkspaceMgr workspaceMgr) |
INDArray |
MKLDNNConvHelper.activate(INDArray z,
IActivation afn,
boolean training) |
FwdPassReturn |
MKLDNNLSTMHelper.activate(Layer layer,
NeuralNetConfiguration conf,
IActivation gateActivationFn,
INDArray input,
INDArray recurrentWeights,
INDArray inputWeights,
INDArray biases,
boolean training,
INDArray prevOutputActivations,
INDArray prevMemCellState,
boolean forBackprop,
boolean forwards,
String inputWeightKey,
INDArray maskArray,
boolean hasPeepholeConnections,
LayerWorkspaceMgr workspaceMgr) |
Pair<Gradient,INDArray> |
MKLDNNLocalResponseNormalizationHelper.backpropGradient(INDArray input,
INDArray epsilon,
double k,
double n,
double alpha,
double beta,
LayerWorkspaceMgr workspaceMgr) |
Pair<Gradient,INDArray> |
MKLDNNConvHelper.backpropGradient(INDArray input,
INDArray weights,
INDArray bias,
INDArray delta,
int[] kernel,
int[] strides,
int[] pad,
INDArray biasGradView,
INDArray weightGradView,
IActivation afn,
ConvolutionLayer.AlgoMode mode,
ConvolutionLayer.BwdFilterAlgo bwdFilterAlgo,
ConvolutionLayer.BwdDataAlgo bwdDataAlgo,
ConvolutionMode convolutionMode,
int[] dilation,
LayerWorkspaceMgr workspaceMgr) |
Pair<Gradient,INDArray> |
MKLDNNSubsamplingHelper.backpropGradient(INDArray input,
INDArray epsilon,
int[] kernel,
int[] strides,
int[] pad,
PoolingType poolingType,
ConvolutionMode convolutionMode,
int[] dilation,
LayerWorkspaceMgr workspaceMgr) |
Pair<Gradient,INDArray> |
MKLDNNBatchNormHelper.backpropGradient(INDArray input,
INDArray epsilon,
long[] shape,
INDArray gamma,
INDArray beta,
INDArray dGammaView,
INDArray dBetaView,
double eps,
LayerWorkspaceMgr workspaceMgr) |
Pair<Gradient,INDArray> |
MKLDNNLSTMHelper.backpropGradient(NeuralNetConfiguration conf,
IActivation gateActivationFn,
INDArray input,
INDArray recurrentWeights,
INDArray inputWeights,
INDArray epsilon,
boolean truncatedBPTT,
int tbpttBackwardLength,
FwdPassReturn fwdPass,
boolean forwards,
String inputWeightKey,
String recurrentWeightKey,
String biasWeightKey,
Map<String,INDArray> gradientViews,
INDArray maskArray,
boolean hasPeepholeConnections,
LayerWorkspaceMgr workspaceMgr) |
INDArray |
MKLDNNBatchNormHelper.preOutput(INDArray x,
boolean training,
long[] shape,
INDArray gamma,
INDArray beta,
INDArray mean,
INDArray var,
double decay,
double eps,
LayerWorkspaceMgr workspaceMgr) |
INDArray |
MKLDNNConvHelper.preOutput(INDArray input,
INDArray weights,
INDArray bias,
int[] kernel,
int[] strides,
int[] pad,
ConvolutionLayer.AlgoMode mode,
ConvolutionLayer.FwdAlgo fwdAlgo,
ConvolutionMode convolutionMode,
int[] dilation,
LayerWorkspaceMgr workspaceMgr) |
| Modifier and Type | Method and Description |
|---|---|
Pair<Gradient,INDArray> |
MKLDNNLSTMHelper.backpropGradient(NeuralNetConfiguration conf,
IActivation gateActivationFn,
INDArray input,
INDArray recurrentWeights,
INDArray inputWeights,
INDArray epsilon,
boolean truncatedBPTT,
int tbpttBackwardLength,
FwdPassReturn fwdPass,
boolean forwards,
String inputWeightKey,
String recurrentWeightKey,
String biasWeightKey,
Map<String,INDArray> gradientViews,
INDArray maskArray,
boolean hasPeepholeConnections,
LayerWorkspaceMgr workspaceMgr) |
| Modifier and Type | Field and Description |
|---|---|
protected INDArray |
BatchNormalization.std |
protected INDArray |
BatchNormalization.xHat |
protected INDArray |
BatchNormalization.xMu |
| Modifier and Type | Method and Description |
|---|---|
INDArray |
LocalResponseNormalization.activate(boolean training,
LayerWorkspaceMgr workspaceMgr) |
INDArray |
BatchNormalization.activate(boolean training,
LayerWorkspaceMgr workspaceMgr) |
INDArray |
LocalResponseNormalizationHelper.activate(INDArray x,
boolean training,
double k,
double n,
double alpha,
double beta,
LayerWorkspaceMgr workspaceMgr) |
INDArray |
BatchNormalizationHelper.getMeanCache(DataType dataType) |
INDArray |
LocalResponseNormalization.getParam(String param) |
INDArray |
BatchNormalizationHelper.getVarCache(DataType dataType) |
INDArray |
LocalResponseNormalization.params() |
INDArray |
BatchNormalizationHelper.preOutput(INDArray x,
boolean training,
long[] shape,
INDArray gamma,
INDArray beta,
INDArray mean,
INDArray var,
double decay,
double eps,
LayerWorkspaceMgr workspaceMgr) |
INDArray |
BatchNormalization.preOutput(INDArray x,
Layer.TrainingMode training,
LayerWorkspaceMgr workspaceMgr) |
| Modifier and Type | Method and Description |
|---|---|
Pair<Gradient,INDArray> |
LocalResponseNormalizationHelper.backpropGradient(INDArray input,
INDArray epsilon,
double k,
double n,
double alpha,
double beta,
LayerWorkspaceMgr workspaceMgr) |
Pair<Gradient,INDArray> |
BatchNormalizationHelper.backpropGradient(INDArray input,
INDArray epsilon,
long[] shape,
INDArray gamma,
INDArray beta,
INDArray dGammaView,
INDArray dBetaView,
double eps,
LayerWorkspaceMgr workspaceMgr) |
Pair<Gradient,INDArray> |
LocalResponseNormalization.backpropGradient(INDArray epsilon,
LayerWorkspaceMgr workspaceMgr) |
Pair<Gradient,INDArray> |
BatchNormalization.backpropGradient(INDArray epsilon,
LayerWorkspaceMgr workspaceMgr) |
| Modifier and Type | Method and Description |
|---|---|
INDArray |
LocalResponseNormalizationHelper.activate(INDArray x,
boolean training,
double k,
double n,
double alpha,
double beta,
LayerWorkspaceMgr workspaceMgr) |
Pair<Gradient,INDArray> |
LocalResponseNormalizationHelper.backpropGradient(INDArray input,
INDArray epsilon,
double k,
double n,
double alpha,
double beta,
LayerWorkspaceMgr workspaceMgr) |
Pair<Gradient,INDArray> |
BatchNormalizationHelper.backpropGradient(INDArray input,
INDArray epsilon,
long[] shape,
INDArray gamma,
INDArray beta,
INDArray dGammaView,
INDArray dBetaView,
double eps,
LayerWorkspaceMgr workspaceMgr) |
Pair<Gradient,INDArray> |
LocalResponseNormalization.backpropGradient(INDArray epsilon,
LayerWorkspaceMgr workspaceMgr) |
Pair<Gradient,INDArray> |
BatchNormalization.backpropGradient(INDArray epsilon,
LayerWorkspaceMgr workspaceMgr) |
void |
LocalResponseNormalization.fit(INDArray input,
LayerWorkspaceMgr workspaceMgr) |
void |
BatchNormalization.fit(INDArray input,
LayerWorkspaceMgr workspaceMgr) |
long[] |
BatchNormalization.getShape(INDArray x) |
INDArray |
BatchNormalizationHelper.preOutput(INDArray x,
boolean training,
long[] shape,
INDArray gamma,
INDArray beta,
INDArray mean,
INDArray var,
double decay,
double eps,
LayerWorkspaceMgr workspaceMgr) |
INDArray |
BatchNormalization.preOutput(INDArray x,
Layer.TrainingMode training,
LayerWorkspaceMgr workspaceMgr) |
void |
LocalResponseNormalization.setParams(INDArray params) |
| Modifier and Type | Field and Description |
|---|---|
protected INDArray |
Yolo2OutputLayer.labels |
| Modifier and Type | Method and Description |
|---|---|
INDArray |
Yolo2OutputLayer.activate(boolean training,
LayerWorkspaceMgr workspaceMgr) |
static INDArray |
YoloUtils.activate(INDArray boundingBoxPriors,
INDArray input)
Essentially: just apply activation functions...
|
static INDArray |
YoloUtils.activate(INDArray boundingBoxPriors,
INDArray input,
LayerWorkspaceMgr layerWorkspaceMgr) |
INDArray |
Yolo2OutputLayer.computeScoreForExamples(double fullNetRegTerm,
LayerWorkspaceMgr workspaceMgr) |
INDArray |
Yolo2OutputLayer.getConfidenceMatrix(INDArray networkOutput,
int example,
int bbNumber)
Get the confidence matrix (confidence for all x/y positions) for the specified bounding box, from the network
output activations array
|
INDArray |
Yolo2OutputLayer.getProbabilityMatrix(INDArray networkOutput,
int example,
int classNumber)
Get the probability matrix (probability of the specified class, assuming an object is present, for all x/y
positions), from the network output activations array
|
| Modifier and Type | Method and Description |
|---|---|
Pair<Gradient,INDArray> |
Yolo2OutputLayer.backpropGradient(INDArray epsilon,
LayerWorkspaceMgr workspaceMgr) |
| Modifier and Type | Method and Description |
|---|---|
static INDArray |
YoloUtils.activate(INDArray boundingBoxPriors,
INDArray input)
Essentially: just apply activation functions...
|
static INDArray |
YoloUtils.activate(INDArray boundingBoxPriors,
INDArray input,
LayerWorkspaceMgr layerWorkspaceMgr) |
Pair<Gradient,INDArray> |
Yolo2OutputLayer.backpropGradient(INDArray epsilon,
LayerWorkspaceMgr workspaceMgr) |
double |
Yolo2OutputLayer.f1Score(INDArray examples,
INDArray labels) |
void |
Yolo2OutputLayer.fit(INDArray examples,
INDArray labels) |
void |
Yolo2OutputLayer.fit(INDArray examples,
int[] labels) |
INDArray |
Yolo2OutputLayer.getConfidenceMatrix(INDArray networkOutput,
int example,
int bbNumber)
Get the confidence matrix (confidence for all x/y positions) for the specified bounding box, from the network
output activations array
|
List<DetectedObject> |
Yolo2OutputLayer.getPredictedObjects(INDArray networkOutput,
double threshold) |
static List<DetectedObject> |
YoloUtils.getPredictedObjects(INDArray boundingBoxPriors,
INDArray networkOutput,
double confThreshold,
double nmsThreshold)
Given the network output and a detection threshold (in range 0 to 1) determine the objects detected by
the network.
|
INDArray |
Yolo2OutputLayer.getProbabilityMatrix(INDArray networkOutput,
int example,
int classNumber)
Get the probability matrix (probability of the specified class, assuming an object is present, for all x/y
positions), from the network output activations array
|
int[] |
Yolo2OutputLayer.predict(INDArray examples) |
| Constructor and Description |
|---|
DetectedObject(int exampleNumber,
double centerX,
double centerY,
double width,
double height,
INDArray classPredictions,
double confidence) |
| Modifier and Type | Method and Description |
|---|---|
INDArray |
OCNNOutputLayer.activate(boolean training,
LayerWorkspaceMgr workspaceMgr) |
INDArray |
OCNNOutputLayer.activate(INDArray input,
boolean training,
LayerWorkspaceMgr workspaceMgr) |
INDArray |
OCNNOutputLayer.OCNNLossFunction.computeGradient(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask) |
INDArray |
OCNNOutputLayer.OCNNLossFunction.computeScoreArray(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask) |
INDArray |
OCNNOutputLayer.computeScoreForExamples(double fullNetRegTerm,
LayerWorkspaceMgr workspaceMgr)
Compute the score for each example individually, after labels and input have been set.
|
protected INDArray |
OCNNParamInitializer.createWeightMatrix(NeuralNetConfiguration configuration,
INDArray weightParamView,
boolean initializeParameters) |
protected INDArray |
OCNNOutputLayer.getLabels2d(LayerWorkspaceMgr workspaceMgr,
ArrayType arrayType) |
protected INDArray |
OCNNOutputLayer.preOutput2d(boolean training,
LayerWorkspaceMgr workspaceMgr) |
| Modifier and Type | Method and Description |
|---|---|
Pair<Gradient,INDArray> |
OCNNOutputLayer.backpropGradient(INDArray epsilon,
LayerWorkspaceMgr workspaceMgr) |
Pair<Double,INDArray> |
OCNNOutputLayer.OCNNLossFunction.computeGradientAndScore(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask,
boolean average) |
Map<String,INDArray> |
OCNNParamInitializer.getGradientsFromFlattened(NeuralNetConfiguration conf,
INDArray gradientView) |
Map<String,INDArray> |
OCNNParamInitializer.init(NeuralNetConfiguration conf,
INDArray paramsView,
boolean initializeParams) |
| Modifier and Type | Method and Description |
|---|---|
INDArray |
OCNNOutputLayer.activate(INDArray input,
boolean training,
LayerWorkspaceMgr workspaceMgr) |
Pair<Gradient,INDArray> |
OCNNOutputLayer.backpropGradient(INDArray epsilon,
LayerWorkspaceMgr workspaceMgr) |
INDArray |
OCNNOutputLayer.OCNNLossFunction.computeGradient(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask) |
Pair<Double,INDArray> |
OCNNOutputLayer.OCNNLossFunction.computeGradientAndScore(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask,
boolean average) |
double |
OCNNOutputLayer.OCNNLossFunction.computeScore(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask,
boolean average) |
INDArray |
OCNNOutputLayer.OCNNLossFunction.computeScoreArray(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask) |
protected INDArray |
OCNNParamInitializer.createWeightMatrix(NeuralNetConfiguration configuration,
INDArray weightParamView,
boolean initializeParameters) |
double |
OCNNOutputLayer.f1Score(INDArray examples,
INDArray labels)
Returns the f1 score for the given examples.
|
Map<String,INDArray> |
OCNNParamInitializer.getGradientsFromFlattened(NeuralNetConfiguration conf,
INDArray gradientView) |
Map<String,INDArray> |
OCNNParamInitializer.init(NeuralNetConfiguration conf,
INDArray paramsView,
boolean initializeParams) |
void |
OCNNOutputLayer.setLabels(INDArray labels) |
| Modifier and Type | Method and Description |
|---|---|
INDArray |
GlobalPoolingLayer.activate(boolean training,
LayerWorkspaceMgr workspaceMgr) |
| Modifier and Type | Method and Description |
|---|---|
Pair<Gradient,INDArray> |
GlobalPoolingLayer.backpropGradient(INDArray epsilon,
LayerWorkspaceMgr workspaceMgr) |
Pair<INDArray,MaskState> |
GlobalPoolingLayer.feedForwardMaskArray(INDArray maskArray,
MaskState currentMaskState,
int minibatchSize) |
| Modifier and Type | Method and Description |
|---|---|
Pair<Gradient,INDArray> |
GlobalPoolingLayer.backpropGradient(INDArray epsilon,
LayerWorkspaceMgr workspaceMgr) |
Pair<INDArray,MaskState> |
GlobalPoolingLayer.feedForwardMaskArray(INDArray maskArray,
MaskState currentMaskState,
int minibatchSize) |
| Modifier and Type | Field and Description |
|---|---|
INDArray[] |
FwdPassReturn.fa |
INDArray |
FwdPassReturn.fwdPassOutput |
INDArray[] |
FwdPassReturn.fwdPassOutputAsArrays |
INDArray[] |
FwdPassReturn.fz |
INDArray[] |
FwdPassReturn.ga |
INDArray[] |
FwdPassReturn.gz |
INDArray[] |
FwdPassReturn.ia |
INDArray[] |
FwdPassReturn.iz |
protected INDArray |
RnnLossLayer.labels |
INDArray |
FwdPassReturn.lastAct |
INDArray |
FwdPassReturn.lastMemCell |
INDArray[] |
FwdPassReturn.memCellActivations |
INDArray[] |
FwdPassReturn.memCellState |
INDArray[] |
FwdPassReturn.oa |
INDArray[] |
FwdPassReturn.oz |
INDArray |
FwdPassReturn.prevAct |
INDArray |
FwdPassReturn.prevMemCell |
| Modifier and Type | Field and Description |
|---|---|
protected Map<String,INDArray> |
BaseRecurrentLayer.stateMap
stateMap stores the INDArrays needed to do rnnTimeStep() forward pass.
|
protected Map<String,INDArray> |
BaseRecurrentLayer.tBpttStateMap
State map for use specifically in truncated BPTT training.
|
| Modifier and Type | Method and Description |
|---|---|
INDArray |
TimeDistributedLayer.activate(boolean training,
LayerWorkspaceMgr workspaceMgr) |
INDArray |
SimpleRnn.activate(boolean training,
LayerWorkspaceMgr workspaceMgr) |
INDArray |
RnnOutputLayer.activate(boolean training,
LayerWorkspaceMgr workspaceMgr) |
INDArray |
RnnLossLayer.activate(boolean training,
LayerWorkspaceMgr workspaceMgr) |
INDArray |
MaskZeroLayer.activate(boolean training,
LayerWorkspaceMgr workspaceMgr) |
INDArray |
LSTM.activate(boolean training,
LayerWorkspaceMgr workspaceMgr) |
INDArray |
LastTimeStepLayer.activate(boolean training,
LayerWorkspaceMgr workspaceMgr) |
INDArray |
GravesLSTM.activate(boolean training,
LayerWorkspaceMgr workspaceMgr)
Deprecated.
|
INDArray |
GravesBidirectionalLSTM.activate(boolean training,
LayerWorkspaceMgr workspaceMgr) |
INDArray |
BidirectionalLayer.activate(boolean training,
LayerWorkspaceMgr workspaceMgr) |
INDArray |
TimeDistributedLayer.activate(INDArray input,
boolean training,
LayerWorkspaceMgr workspaceMgr) |
INDArray |
MaskZeroLayer.activate(INDArray input,
boolean training,
LayerWorkspaceMgr workspaceMgr) |
INDArray |
LSTM.activate(INDArray input,
boolean training,
LayerWorkspaceMgr workspaceMgr) |
INDArray |
LastTimeStepLayer.activate(INDArray input,
boolean training,
LayerWorkspaceMgr workspaceMgr) |
INDArray |
GravesLSTM.activate(INDArray input,
boolean training,
LayerWorkspaceMgr workspaceMgr)
Deprecated.
|
INDArray |
GravesBidirectionalLSTM.activate(INDArray input,
boolean training,
LayerWorkspaceMgr workspaceMgr) |
INDArray |
BidirectionalLayer.activate(INDArray input,
boolean training,
LayerWorkspaceMgr workspaceMgr) |
INDArray |
RnnOutputLayer.computeScoreForExamples(double fullNetRegTerm,
LayerWorkspaceMgr workspaceMgr)
Compute the score for each example individually, after labels and input have been set.
|
INDArray |
RnnLossLayer.computeScoreForExamples(double fullNetRegTerm,
LayerWorkspaceMgr workspaceMgr)
Compute the score for each example individually, after labels and input have been set.
|
INDArray |
BidirectionalLayer.getGradientsViewArray() |
INDArray |
RnnOutputLayer.getInput() |
protected INDArray |
RnnOutputLayer.getLabels2d(LayerWorkspaceMgr workspaceMgr,
ArrayType arrayType) |
INDArray |
BidirectionalLayer.getMaskArray() |
INDArray |
BidirectionalLayer.getParam(String param) |
INDArray |
BidirectionalLayer.input() |
INDArray |
BidirectionalLayer.params() |
protected INDArray |
RnnOutputLayer.preOutput2d(boolean training,
LayerWorkspaceMgr workspaceMgr) |
protected INDArray |
TimeDistributedLayer.reshape(INDArray array) |
protected INDArray |
TimeDistributedLayer.revertReshape(INDArray toRevert,
long minibatch) |
INDArray |
SimpleRnn.rnnActivateUsingStoredState(INDArray input,
boolean training,
boolean storeLastForTBPTT,
LayerWorkspaceMgr workspaceMgr) |
INDArray |
LSTM.rnnActivateUsingStoredState(INDArray input,
boolean training,
boolean storeLastForTBPTT,
LayerWorkspaceMgr workspaceMgr) |
INDArray |
GravesLSTM.rnnActivateUsingStoredState(INDArray input,
boolean training,
boolean storeLastForTBPTT,
LayerWorkspaceMgr workspaceMgr)
Deprecated.
|
INDArray |
GravesBidirectionalLSTM.rnnActivateUsingStoredState(INDArray input,
boolean training,
boolean storeLastForTBPTT,
LayerWorkspaceMgr workspaceMgr) |
INDArray |
BidirectionalLayer.rnnActivateUsingStoredState(INDArray input,
boolean training,
boolean storeLastForTBPTT,
LayerWorkspaceMgr workspaceMgr) |
INDArray |
SimpleRnn.rnnTimeStep(INDArray input,
LayerWorkspaceMgr workspaceMgr) |
INDArray |
LSTM.rnnTimeStep(INDArray input,
LayerWorkspaceMgr workspaceMgr) |
INDArray |
GravesLSTM.rnnTimeStep(INDArray input,
LayerWorkspaceMgr workspaceMgr)
Deprecated.
|
INDArray |
GravesBidirectionalLSTM.rnnTimeStep(INDArray input,
LayerWorkspaceMgr workspaceMgr) |
INDArray |
BidirectionalLayer.rnnTimeStep(INDArray input,
LayerWorkspaceMgr workspaceMgr) |
| Modifier and Type | Method and Description |
|---|---|
Pair<Gradient,INDArray> |
TimeDistributedLayer.backpropGradient(INDArray epsilon,
LayerWorkspaceMgr workspaceMgr) |
Pair<Gradient,INDArray> |
SimpleRnn.backpropGradient(INDArray epsilon,
LayerWorkspaceMgr workspaceMgr) |
Pair<Gradient,INDArray> |
RnnOutputLayer.backpropGradient(INDArray epsilon,
LayerWorkspaceMgr workspaceMgr) |
Pair<Gradient,INDArray> |
RnnLossLayer.backpropGradient(INDArray epsilon,
LayerWorkspaceMgr workspaceMgr) |
Pair<Gradient,INDArray> |
MaskZeroLayer.backpropGradient(INDArray epsilon,
LayerWorkspaceMgr workspaceMgr) |
Pair<Gradient,INDArray> |
LSTM.backpropGradient(INDArray epsilon,
LayerWorkspaceMgr workspaceMgr) |
Pair<Gradient,INDArray> |
LastTimeStepLayer.backpropGradient(INDArray epsilon,
LayerWorkspaceMgr workspaceMgr) |
Pair<Gradient,INDArray> |
GravesLSTM.backpropGradient(INDArray epsilon,
LayerWorkspaceMgr workspaceMgr)
Deprecated.
|
Pair<Gradient,INDArray> |
GravesBidirectionalLSTM.backpropGradient(INDArray epsilon,
LayerWorkspaceMgr workspaceMgr) |
Pair<Gradient,INDArray> |
BidirectionalLayer.backpropGradient(INDArray epsilon,
LayerWorkspaceMgr workspaceMgr) |
Pair<Gradient,INDArray> |
LSTMHelper.backpropGradient(NeuralNetConfiguration conf,
IActivation gateActivationFn,
INDArray input,
INDArray recurrentWeights,
INDArray inputWeights,
INDArray epsilon,
boolean truncatedBPTT,
int tbpttBackwardLength,
FwdPassReturn fwdPass,
boolean forwards,
String inputWeightKey,
String recurrentWeightKey,
String biasWeightKey,
Map<String,INDArray> gradientViews,
INDArray maskArray,
boolean hasPeepholeConnections,
LayerWorkspaceMgr workspaceMgr) |
static Pair<Gradient,INDArray> |
LSTMHelpers.backpropGradientHelper(BaseRecurrentLayer layer,
NeuralNetConfiguration conf,
IActivation gateActivationFn,
INDArray input,
INDArray recurrentWeights,
INDArray inputWeights,
INDArray epsilon,
boolean truncatedBPTT,
int tbpttBackwardLength,
FwdPassReturn fwdPass,
boolean forwards,
String inputWeightKey,
String recurrentWeightKey,
String biasWeightKey,
Map<String,INDArray> gradientViews,
INDArray maskArray,
boolean hasPeepholeConnections,
LSTMHelper helper,
LayerWorkspaceMgr workspaceMgr,
boolean isHelperAllowFallback) |
Pair<INDArray,MaskState> |
TimeDistributedLayer.feedForwardMaskArray(INDArray maskArray,
MaskState currentMaskState,
int minibatchSize) |
Pair<INDArray,MaskState> |
RnnOutputLayer.feedForwardMaskArray(INDArray maskArray,
MaskState currentMaskState,
int minibatchSize) |
Pair<INDArray,MaskState> |
RnnLossLayer.feedForwardMaskArray(INDArray maskArray,
MaskState currentMaskState,
int minibatchSize) |
Pair<INDArray,MaskState> |
MaskZeroLayer.feedForwardMaskArray(INDArray maskArray,
MaskState currentMaskState,
int minibatchSize) |
Pair<INDArray,MaskState> |
LSTM.feedForwardMaskArray(INDArray maskArray,
MaskState currentMaskState,
int minibatchSize) |
Pair<INDArray,MaskState> |
LastTimeStepLayer.feedForwardMaskArray(INDArray maskArray,
MaskState currentMaskState,
int minibatchSize) |
Pair<INDArray,MaskState> |
GravesLSTM.feedForwardMaskArray(INDArray maskArray,
MaskState currentMaskState,
int minibatchSize)
Deprecated.
|
Pair<INDArray,MaskState> |
GravesBidirectionalLSTM.feedForwardMaskArray(INDArray maskArray,
MaskState currentMaskState,
int minibatchSize) |
Pair<INDArray,MaskState> |
BidirectionalLayer.feedForwardMaskArray(INDArray maskArray,
MaskState currentMaskState,
int minibatchSize) |
Map<String,INDArray> |
BidirectionalLayer.paramTable() |
Map<String,INDArray> |
BidirectionalLayer.paramTable(boolean backpropParamsOnly) |
Map<String,INDArray> |
BidirectionalLayer.rnnGetPreviousState() |
Map<String,INDArray> |
BaseRecurrentLayer.rnnGetPreviousState()
Returns a shallow copy of the stateMap
|
Map<String,INDArray> |
BidirectionalLayer.rnnGetTBPTTState() |
Map<String,INDArray> |
BaseRecurrentLayer.rnnGetTBPTTState() |
Pair<Gradient,INDArray> |
SimpleRnn.tbpttBackpropGradient(INDArray epsilon,
int tbpttBackLength,
LayerWorkspaceMgr workspaceMgr) |
Pair<Gradient,INDArray> |
LSTM.tbpttBackpropGradient(INDArray epsilon,
int tbpttBackwardLength,
LayerWorkspaceMgr workspaceMgr) |
Pair<Gradient,INDArray> |
GravesLSTM.tbpttBackpropGradient(INDArray epsilon,
int tbpttBackwardLength,
LayerWorkspaceMgr workspaceMgr)
Deprecated.
|
Pair<Gradient,INDArray> |
GravesBidirectionalLSTM.tbpttBackpropGradient(INDArray epsilon,
int tbpttBackwardLength,
LayerWorkspaceMgr workspaceMgr) |
Pair<Gradient,INDArray> |
BidirectionalLayer.tbpttBackpropGradient(INDArray epsilon,
int tbpttBackLength,
LayerWorkspaceMgr workspaceMgr) |
| Modifier and Type | Method and Description |
|---|---|
INDArray |
TimeDistributedLayer.activate(INDArray input,
boolean training,
LayerWorkspaceMgr workspaceMgr) |
INDArray |
MaskZeroLayer.activate(INDArray input,
boolean training,
LayerWorkspaceMgr workspaceMgr) |
INDArray |
LSTM.activate(INDArray input,
boolean training,
LayerWorkspaceMgr workspaceMgr) |
INDArray |
LastTimeStepLayer.activate(INDArray input,
boolean training,
LayerWorkspaceMgr workspaceMgr) |
INDArray |
GravesLSTM.activate(INDArray input,
boolean training,
LayerWorkspaceMgr workspaceMgr)
Deprecated.
|
INDArray |
GravesBidirectionalLSTM.activate(INDArray input,
boolean training,
LayerWorkspaceMgr workspaceMgr) |
INDArray |
BidirectionalLayer.activate(INDArray input,
boolean training,
LayerWorkspaceMgr workspaceMgr) |
FwdPassReturn |
LSTMHelper.activate(Layer layer,
NeuralNetConfiguration conf,
IActivation gateActivationFn,
INDArray input,
INDArray recurrentWeights,
INDArray inputWeights,
INDArray biases,
boolean training,
INDArray prevOutputActivations,
INDArray prevMemCellState,
boolean forBackprop,
boolean forwards,
String inputWeightKey,
INDArray maskArray,
boolean hasPeepholeConnections,
LayerWorkspaceMgr workspaceMgr) |
static FwdPassReturn |
LSTMHelpers.activateHelper(BaseRecurrentLayer layer,
NeuralNetConfiguration conf,
IActivation gateActivationFn,
INDArray input,
INDArray recurrentWeights,
INDArray originalInputWeights,
INDArray biases,
boolean training,
INDArray originalPrevOutputActivations,
INDArray originalPrevMemCellState,
boolean forBackprop,
boolean forwards,
String inputWeightKey,
INDArray maskArray,
boolean hasPeepholeConnections,
LSTMHelper helper,
CacheMode cacheMode,
LayerWorkspaceMgr workspaceMgr,
boolean isHelperAllowFallback)
Returns FwdPassReturn object with activations/INDArrays.
|
Pair<Gradient,INDArray> |
TimeDistributedLayer.backpropGradient(INDArray epsilon,
LayerWorkspaceMgr workspaceMgr) |
Pair<Gradient,INDArray> |
SimpleRnn.backpropGradient(INDArray epsilon,
LayerWorkspaceMgr workspaceMgr) |
Pair<Gradient,INDArray> |
RnnOutputLayer.backpropGradient(INDArray epsilon,
LayerWorkspaceMgr workspaceMgr) |
Pair<Gradient,INDArray> |
RnnLossLayer.backpropGradient(INDArray epsilon,
LayerWorkspaceMgr workspaceMgr) |
Pair<Gradient,INDArray> |
MaskZeroLayer.backpropGradient(INDArray epsilon,
LayerWorkspaceMgr workspaceMgr) |
Pair<Gradient,INDArray> |
LSTM.backpropGradient(INDArray epsilon,
LayerWorkspaceMgr workspaceMgr) |
Pair<Gradient,INDArray> |
LastTimeStepLayer.backpropGradient(INDArray epsilon,
LayerWorkspaceMgr workspaceMgr) |
Pair<Gradient,INDArray> |
GravesLSTM.backpropGradient(INDArray epsilon,
LayerWorkspaceMgr workspaceMgr)
Deprecated.
|
Pair<Gradient,INDArray> |
GravesBidirectionalLSTM.backpropGradient(INDArray epsilon,
LayerWorkspaceMgr workspaceMgr) |
Pair<Gradient,INDArray> |
BidirectionalLayer.backpropGradient(INDArray epsilon,
LayerWorkspaceMgr workspaceMgr) |
Pair<Gradient,INDArray> |
LSTMHelper.backpropGradient(NeuralNetConfiguration conf,
IActivation gateActivationFn,
INDArray input,
INDArray recurrentWeights,
INDArray inputWeights,
INDArray epsilon,
boolean truncatedBPTT,
int tbpttBackwardLength,
FwdPassReturn fwdPass,
boolean forwards,
String inputWeightKey,
String recurrentWeightKey,
String biasWeightKey,
Map<String,INDArray> gradientViews,
INDArray maskArray,
boolean hasPeepholeConnections,
LayerWorkspaceMgr workspaceMgr) |
static Pair<Gradient,INDArray> |
LSTMHelpers.backpropGradientHelper(BaseRecurrentLayer layer,
NeuralNetConfiguration conf,
IActivation gateActivationFn,
INDArray input,
INDArray recurrentWeights,
INDArray inputWeights,
INDArray epsilon,
boolean truncatedBPTT,
int tbpttBackwardLength,
FwdPassReturn fwdPass,
boolean forwards,
String inputWeightKey,
String recurrentWeightKey,
String biasWeightKey,
Map<String,INDArray> gradientViews,
INDArray maskArray,
boolean hasPeepholeConnections,
LSTMHelper helper,
LayerWorkspaceMgr workspaceMgr,
boolean isHelperAllowFallback) |
double |
RnnOutputLayer.f1Score(INDArray examples,
INDArray labels)
Returns the f1 score for the given examples.
|
double |
RnnLossLayer.f1Score(INDArray examples,
INDArray labels)
Returns the f1 score for the given examples.
|
Pair<INDArray,MaskState> |
TimeDistributedLayer.feedForwardMaskArray(INDArray maskArray,
MaskState currentMaskState,
int minibatchSize) |
Pair<INDArray,MaskState> |
RnnOutputLayer.feedForwardMaskArray(INDArray maskArray,
MaskState currentMaskState,
int minibatchSize) |
Pair<INDArray,MaskState> |
RnnLossLayer.feedForwardMaskArray(INDArray maskArray,
MaskState currentMaskState,
int minibatchSize) |
Pair<INDArray,MaskState> |
MaskZeroLayer.feedForwardMaskArray(INDArray maskArray,
MaskState currentMaskState,
int minibatchSize) |
Pair<INDArray,MaskState> |
LSTM.feedForwardMaskArray(INDArray maskArray,
MaskState currentMaskState,
int minibatchSize) |
Pair<INDArray,MaskState> |
LastTimeStepLayer.feedForwardMaskArray(INDArray maskArray,
MaskState currentMaskState,
int minibatchSize) |
Pair<INDArray,MaskState> |
GravesLSTM.feedForwardMaskArray(INDArray maskArray,
MaskState currentMaskState,
int minibatchSize)
Deprecated.
|
Pair<INDArray,MaskState> |
GravesBidirectionalLSTM.feedForwardMaskArray(INDArray maskArray,
MaskState currentMaskState,
int minibatchSize) |
Pair<INDArray,MaskState> |
BidirectionalLayer.feedForwardMaskArray(INDArray maskArray,
MaskState currentMaskState,
int minibatchSize) |
void |
RnnLossLayer.fit(INDArray examples,
INDArray labels) |
void |
RnnLossLayer.fit(INDArray examples,
int[] labels) |
void |
BidirectionalLayer.fit(INDArray data,
LayerWorkspaceMgr workspaceMgr) |
int[] |
RnnLossLayer.predict(INDArray examples) |
protected INDArray |
TimeDistributedLayer.reshape(INDArray array) |
protected INDArray |
TimeDistributedLayer.revertReshape(INDArray toRevert,
long minibatch) |
INDArray |
SimpleRnn.rnnActivateUsingStoredState(INDArray input,
boolean training,
boolean storeLastForTBPTT,
LayerWorkspaceMgr workspaceMgr) |
INDArray |
LSTM.rnnActivateUsingStoredState(INDArray input,
boolean training,
boolean storeLastForTBPTT,
LayerWorkspaceMgr workspaceMgr) |
INDArray |
GravesLSTM.rnnActivateUsingStoredState(INDArray input,
boolean training,
boolean storeLastForTBPTT,
LayerWorkspaceMgr workspaceMgr)
Deprecated.
|
INDArray |
GravesBidirectionalLSTM.rnnActivateUsingStoredState(INDArray input,
boolean training,
boolean storeLastForTBPTT,
LayerWorkspaceMgr workspaceMgr) |
INDArray |
BidirectionalLayer.rnnActivateUsingStoredState(INDArray input,
boolean training,
boolean storeLastForTBPTT,
LayerWorkspaceMgr workspaceMgr) |
INDArray |
SimpleRnn.rnnTimeStep(INDArray input,
LayerWorkspaceMgr workspaceMgr) |
INDArray |
LSTM.rnnTimeStep(INDArray input,
LayerWorkspaceMgr workspaceMgr) |
INDArray |
GravesLSTM.rnnTimeStep(INDArray input,
LayerWorkspaceMgr workspaceMgr)
Deprecated.
|
INDArray |
GravesBidirectionalLSTM.rnnTimeStep(INDArray input,
LayerWorkspaceMgr workspaceMgr) |
INDArray |
BidirectionalLayer.rnnTimeStep(INDArray input,
LayerWorkspaceMgr workspaceMgr) |
void |
BidirectionalLayer.setBackpropGradientsViewArray(INDArray gradients) |
void |
BidirectionalLayer.setInput(INDArray input,
LayerWorkspaceMgr layerWorkspaceMgr) |
void |
TimeDistributedLayer.setMaskArray(INDArray maskArray) |
void |
RnnOutputLayer.setMaskArray(INDArray maskArray) |
void |
RnnLossLayer.setMaskArray(INDArray maskArray) |
void |
BidirectionalLayer.setMaskArray(INDArray maskArray) |
void |
BidirectionalLayer.setParam(String key,
INDArray val) |
void |
BidirectionalLayer.setParams(INDArray params) |
void |
BidirectionalLayer.setParamsViewArray(INDArray params) |
Pair<Gradient,INDArray> |
SimpleRnn.tbpttBackpropGradient(INDArray epsilon,
int tbpttBackLength,
LayerWorkspaceMgr workspaceMgr) |
Pair<Gradient,INDArray> |
LSTM.tbpttBackpropGradient(INDArray epsilon,
int tbpttBackwardLength,
LayerWorkspaceMgr workspaceMgr) |
Pair<Gradient,INDArray> |
GravesLSTM.tbpttBackpropGradient(INDArray epsilon,
int tbpttBackwardLength,
LayerWorkspaceMgr workspaceMgr)
Deprecated.
|
Pair<Gradient,INDArray> |
GravesBidirectionalLSTM.tbpttBackpropGradient(INDArray epsilon,
int tbpttBackwardLength,
LayerWorkspaceMgr workspaceMgr) |
Pair<Gradient,INDArray> |
BidirectionalLayer.tbpttBackpropGradient(INDArray epsilon,
int tbpttBackLength,
LayerWorkspaceMgr workspaceMgr) |
void |
BidirectionalLayer.update(INDArray gradient,
String paramType) |
| Modifier and Type | Method and Description |
|---|---|
Pair<Gradient,INDArray> |
LSTMHelper.backpropGradient(NeuralNetConfiguration conf,
IActivation gateActivationFn,
INDArray input,
INDArray recurrentWeights,
INDArray inputWeights,
INDArray epsilon,
boolean truncatedBPTT,
int tbpttBackwardLength,
FwdPassReturn fwdPass,
boolean forwards,
String inputWeightKey,
String recurrentWeightKey,
String biasWeightKey,
Map<String,INDArray> gradientViews,
INDArray maskArray,
boolean hasPeepholeConnections,
LayerWorkspaceMgr workspaceMgr) |
static Pair<Gradient,INDArray> |
LSTMHelpers.backpropGradientHelper(BaseRecurrentLayer layer,
NeuralNetConfiguration conf,
IActivation gateActivationFn,
INDArray input,
INDArray recurrentWeights,
INDArray inputWeights,
INDArray epsilon,
boolean truncatedBPTT,
int tbpttBackwardLength,
FwdPassReturn fwdPass,
boolean forwards,
String inputWeightKey,
String recurrentWeightKey,
String biasWeightKey,
Map<String,INDArray> gradientViews,
INDArray maskArray,
boolean hasPeepholeConnections,
LSTMHelper helper,
LayerWorkspaceMgr workspaceMgr,
boolean isHelperAllowFallback) |
void |
BidirectionalLayer.rnnSetPreviousState(Map<String,INDArray> stateMap) |
void |
BaseRecurrentLayer.rnnSetPreviousState(Map<String,INDArray> stateMap)
Set the state map.
|
void |
BidirectionalLayer.rnnSetTBPTTState(Map<String,INDArray> state) |
void |
BaseRecurrentLayer.rnnSetTBPTTState(Map<String,INDArray> state) |
void |
BidirectionalLayer.setParamTable(Map<String,INDArray> paramTable) |
| Constructor and Description |
|---|
BidirectionalLayer(NeuralNetConfiguration conf,
Layer fwd,
Layer bwd,
INDArray paramsView) |
| Modifier and Type | Field and Description |
|---|---|
protected INDArray |
SameDiffOutputLayer.gradients |
protected INDArray |
SameDiffLayer.gradients |
protected INDArray |
SameDiffGraphVertex.gradients |
protected INDArray |
SameDiffOutputLayer.labels |
protected INDArray[] |
SameDiffGraphVertex.maskArrays |
protected INDArray |
SameDiffOutputLayer.params |
protected INDArray |
SameDiffLayer.params |
protected INDArray |
SameDiffGraphVertex.params |
| Modifier and Type | Field and Description |
|---|---|
protected Map<String,INDArray> |
SameDiffOutputLayer.gradTable |
protected Map<String,INDArray> |
SameDiffLayer.gradTable |
protected Map<String,INDArray> |
SameDiffGraphVertex.gradTable |
protected Map<String,INDArray> |
SameDiffOutputLayer.paramTable |
protected Map<String,INDArray> |
SameDiffLayer.paramTable |
protected Map<String,INDArray> |
SameDiffGraphVertex.paramTable |
| Modifier and Type | Method and Description |
|---|---|
INDArray |
SameDiffOutputLayer.activate(boolean training,
LayerWorkspaceMgr workspaceMgr) |
INDArray |
SameDiffLayer.activate(boolean training,
LayerWorkspaceMgr workspaceMgr) |
INDArray |
DL4JSameDiffMemoryMgr.allocate(boolean detached,
DataType dataType,
long... shape) |
INDArray |
DL4JSameDiffMemoryMgr.allocate(boolean detached,
LongShapeDescriptor descriptor) |
INDArray |
SameDiffOutputLayer.computeScoreForExamples(double fullNetRegTerm,
LayerWorkspaceMgr workspaceMgr) |
INDArray |
SameDiffGraphVertex.doForward(boolean training,
LayerWorkspaceMgr workspaceMgr) |
INDArray |
SameDiffOutputLayer.getGradientsViewArray() |
INDArray |
SameDiffLayer.getGradientsViewArray() |
INDArray |
SameDiffGraphVertex.getGradientsViewArray() |
INDArray |
SameDiffOutputLayer.getParam(String param) |
INDArray |
SameDiffLayer.getParam(String param) |
INDArray |
SameDiffOutputLayer.params()
Returns the parameters of the neural network as a flattened row vector
|
INDArray |
SameDiffLayer.params()
Returns the parameters of the neural network as a flattened row vector
|
INDArray |
SameDiffGraphVertex.params() |
| Modifier and Type | Method and Description |
|---|---|
Pair<Gradient,INDArray> |
SameDiffOutputLayer.backpropGradient(INDArray epsilon,
LayerWorkspaceMgr workspaceMgr) |
Pair<Gradient,INDArray> |
SameDiffLayer.backpropGradient(INDArray epsilon,
LayerWorkspaceMgr workspaceMgr) |
Pair<INDArray,MaskState> |
SameDiffLayer.feedForwardMaskArray(INDArray maskArray,
MaskState currentMaskState,
int minibatchSize) |
Pair<INDArray,MaskState> |
SameDiffGraphVertex.feedForwardMaskArrays(INDArray[] maskArrays,
MaskState currentMaskState,
int minibatchSize) |
Map<String,INDArray> |
SameDiffOutputLayer.paramTable() |
Map<String,INDArray> |
SameDiffLayer.paramTable() |
Map<String,INDArray> |
SameDiffOutputLayer.paramTable(boolean backpropParamsOnly) |
Map<String,INDArray> |
SameDiffLayer.paramTable(boolean backpropParamsOnly) |
Map<String,INDArray> |
SameDiffGraphVertex.paramTable(boolean backpropOnly) |
| Modifier and Type | Method and Description |
|---|---|
Pair<Gradient,INDArray> |
SameDiffOutputLayer.backpropGradient(INDArray epsilon,
LayerWorkspaceMgr workspaceMgr) |
Pair<Gradient,INDArray> |
SameDiffLayer.backpropGradient(INDArray epsilon,
LayerWorkspaceMgr workspaceMgr) |
double |
SameDiffOutputLayer.f1Score(INDArray examples,
INDArray labels) |
Pair<INDArray,MaskState> |
SameDiffLayer.feedForwardMaskArray(INDArray maskArray,
MaskState currentMaskState,
int minibatchSize) |
Pair<INDArray,MaskState> |
SameDiffGraphVertex.feedForwardMaskArrays(INDArray[] maskArrays,
MaskState currentMaskState,
int minibatchSize) |
void |
SameDiffOutputLayer.fit(INDArray examples,
INDArray labels) |
void |
SameDiffOutputLayer.fit(INDArray examples,
int[] labels) |
int[] |
SameDiffOutputLayer.predict(INDArray examples) |
void |
DL4JSameDiffMemoryMgr.release(INDArray array) |
void |
SameDiffOutputLayer.setBackpropGradientsViewArray(INDArray gradients) |
void |
SameDiffLayer.setBackpropGradientsViewArray(INDArray gradients) |
void |
SameDiffGraphVertex.setBackpropGradientsViewArray(INDArray backpropGradientsViewArray) |
void |
SameDiffOutputLayer.setParam(String key,
INDArray val) |
void |
SameDiffLayer.setParam(String key,
INDArray val) |
void |
SameDiffOutputLayer.setParams(INDArray params) |
void |
SameDiffLayer.setParams(INDArray params) |
protected void |
SameDiffOutputLayer.setParams(INDArray params,
char order) |
protected void |
SameDiffLayer.setParams(INDArray params,
char order) |
void |
SameDiffOutputLayer.setParamsViewArray(INDArray params) |
void |
SameDiffLayer.setParamsViewArray(INDArray params) |
| Modifier and Type | Method and Description |
|---|---|
void |
SameDiffOutputLayer.setParamTable(Map<String,INDArray> paramTable) |
void |
SameDiffLayer.setParamTable(Map<String,INDArray> paramTable) |
| Constructor and Description |
|---|
SameDiffGraphVertex(SameDiffVertex config,
ComputationGraph graph,
String name,
int vertexIndex,
INDArray paramsView,
boolean initParams,
DataType dataType) |
| Modifier and Type | Method and Description |
|---|---|
INDArray |
CenterLossOutputLayer.computeScoreForExamples(double fullNetRegTerm,
LayerWorkspaceMgr workspaceMgr)
Compute the score for each example individually, after labels and input have been set.
|
protected INDArray |
CenterLossOutputLayer.getLabels2d(LayerWorkspaceMgr workspaceMgr,
ArrayType arrayType) |
| Modifier and Type | Method and Description |
|---|---|
Pair<Gradient,INDArray> |
CenterLossOutputLayer.backpropGradient(INDArray epsilon,
LayerWorkspaceMgr workspaceMgr) |
| Modifier and Type | Method and Description |
|---|---|
Pair<Gradient,INDArray> |
CenterLossOutputLayer.backpropGradient(INDArray epsilon,
LayerWorkspaceMgr workspaceMgr) |
protected void |
CenterLossOutputLayer.setScoreWithZ(INDArray z) |
| Modifier and Type | Method and Description |
|---|---|
INDArray |
MaskLayer.activate(boolean training,
LayerWorkspaceMgr workspaceMgr) |
| Modifier and Type | Method and Description |
|---|---|
Pair<Gradient,INDArray> |
MaskLayer.backpropGradient(INDArray epsilon,
LayerWorkspaceMgr workspaceMgr) |
| Modifier and Type | Method and Description |
|---|---|
Pair<Gradient,INDArray> |
MaskLayer.backpropGradient(INDArray epsilon,
LayerWorkspaceMgr workspaceMgr) |
| Modifier and Type | Field and Description |
|---|---|
protected INDArray |
VariationalAutoencoder.gradientsFlattened |
protected INDArray |
VariationalAutoencoder.input |
protected INDArray |
VariationalAutoencoder.maskArray |
protected INDArray |
VariationalAutoencoder.paramsFlattened |
| Modifier and Type | Field and Description |
|---|---|
protected Map<String,INDArray> |
VariationalAutoencoder.gradientViews |
protected Map<String,INDArray> |
VariationalAutoencoder.params |
protected Map<String,INDArray> |
VariationalAutoencoder.weightNoiseParams |
| Modifier and Type | Method and Description |
|---|---|
INDArray |
VariationalAutoencoder.activate(boolean training,
LayerWorkspaceMgr workspaceMgr) |
INDArray |
VariationalAutoencoder.activate(INDArray input,
boolean training,
LayerWorkspaceMgr workspaceMgr) |
INDArray |
VariationalAutoencoder.generateAtMeanGivenZ(INDArray latentSpaceValues)
Given a specified values for the latent space as input (latent space being z in p(z|data)), generate output
from P(x|z), where x = E[P(x|z)]
i.e., return the mean value for the distribution P(x|z) |
INDArray |
VariationalAutoencoder.generateRandomGivenZ(INDArray latentSpaceValues,
LayerWorkspaceMgr workspaceMgr)
Given a specified values for the latent space as input (latent space being z in p(z|data)), randomly generate output
x, where x ~ P(x|z)
|
INDArray |
VariationalAutoencoder.getGradientsViewArray() |
INDArray |
VariationalAutoencoder.getMaskArray() |
INDArray |
VariationalAutoencoder.getParam(String param) |
protected INDArray |
VariationalAutoencoder.getParamWithNoise(String param,
boolean training,
LayerWorkspaceMgr workspaceMgr) |
INDArray |
VariationalAutoencoder.input() |
INDArray |
VariationalAutoencoder.params() |
INDArray |
VariationalAutoencoder.preOutput(boolean training,
LayerWorkspaceMgr workspaceMgr) |
INDArray |
VariationalAutoencoder.reconstructionError(INDArray data)
Return the reconstruction error for this variational autoencoder.
|
INDArray |
VariationalAutoencoder.reconstructionLogProbability(INDArray data,
int numSamples)
Return the log reconstruction probability given the specified number of samples.
|
INDArray |
VariationalAutoencoder.reconstructionProbability(INDArray data,
int numSamples)
Calculate the reconstruction probability, as described in An & Cho, 2015 - "Variational Autoencoder based
Anomaly Detection using Reconstruction Probability" (Algorithm 4)
The authors describe it as follows: "This is essentially the probability of the data being generated from a given latent variable drawn from the approximate posterior distribution." |
| Modifier and Type | Method and Description |
|---|---|
Pair<Gradient,INDArray> |
VariationalAutoencoder.backpropGradient(INDArray epsilon,
LayerWorkspaceMgr workspaceMgr) |
Pair<INDArray,MaskState> |
VariationalAutoencoder.feedForwardMaskArray(INDArray maskArray,
MaskState currentMaskState,
int minibatchSize) |
Map<String,INDArray> |
VariationalAutoencoder.paramTable() |
Map<String,INDArray> |
VariationalAutoencoder.paramTable(boolean backpropParamsOnly) |
| Modifier and Type | Method and Description |
|---|---|
INDArray |
VariationalAutoencoder.activate(INDArray input,
boolean training,
LayerWorkspaceMgr workspaceMgr) |
Pair<Gradient,INDArray> |
VariationalAutoencoder.backpropGradient(INDArray epsilon,
LayerWorkspaceMgr workspaceMgr) |
Pair<INDArray,MaskState> |
VariationalAutoencoder.feedForwardMaskArray(INDArray maskArray,
MaskState currentMaskState,
int minibatchSize) |
void |
VariationalAutoencoder.fit(INDArray data,
LayerWorkspaceMgr workspaceMgr) |
INDArray |
VariationalAutoencoder.generateAtMeanGivenZ(INDArray latentSpaceValues)
Given a specified values for the latent space as input (latent space being z in p(z|data)), generate output
from P(x|z), where x = E[P(x|z)]
i.e., return the mean value for the distribution P(x|z) |
INDArray |
VariationalAutoencoder.generateRandomGivenZ(INDArray latentSpaceValues,
LayerWorkspaceMgr workspaceMgr)
Given a specified values for the latent space as input (latent space being z in p(z|data)), randomly generate output
x, where x ~ P(x|z)
|
INDArray |
VariationalAutoencoder.reconstructionError(INDArray data)
Return the reconstruction error for this variational autoencoder.
|
INDArray |
VariationalAutoencoder.reconstructionLogProbability(INDArray data,
int numSamples)
Return the log reconstruction probability given the specified number of samples.
|
INDArray |
VariationalAutoencoder.reconstructionProbability(INDArray data,
int numSamples)
Calculate the reconstruction probability, as described in An & Cho, 2015 - "Variational Autoencoder based
Anomaly Detection using Reconstruction Probability" (Algorithm 4)
The authors describe it as follows: "This is essentially the probability of the data being generated from a given latent variable drawn from the approximate posterior distribution." |
void |
VariationalAutoencoder.setBackpropGradientsViewArray(INDArray gradients) |
void |
VariationalAutoencoder.setInput(INDArray input,
LayerWorkspaceMgr layerWorkspaceMgr) |
void |
VariationalAutoencoder.setMaskArray(INDArray maskArray) |
void |
VariationalAutoencoder.setParam(String key,
INDArray val) |
void |
VariationalAutoencoder.setParams(INDArray params) |
void |
VariationalAutoencoder.setParamsViewArray(INDArray params) |
void |
VariationalAutoencoder.update(INDArray gradient,
String paramType) |
| Modifier and Type | Method and Description |
|---|---|
void |
VariationalAutoencoder.setParamTable(Map<String,INDArray> paramTable) |
| Modifier and Type | Method and Description |
|---|---|
INDArray |
BaseWrapperLayer.activate(boolean training,
LayerWorkspaceMgr workspaceMgr) |
INDArray |
BaseWrapperLayer.activate(INDArray input,
boolean training,
LayerWorkspaceMgr workspaceMgr) |
INDArray |
BaseWrapperLayer.getGradientsViewArray() |
INDArray |
BaseWrapperLayer.getMaskArray() |
INDArray |
BaseWrapperLayer.getParam(String param) |
INDArray |
BaseWrapperLayer.input() |
INDArray |
BaseWrapperLayer.params() |
| Modifier and Type | Method and Description |
|---|---|
Pair<Gradient,INDArray> |
BaseWrapperLayer.backpropGradient(INDArray epsilon,
LayerWorkspaceMgr workspaceMgr) |
Pair<INDArray,MaskState> |
BaseWrapperLayer.feedForwardMaskArray(INDArray maskArray,
MaskState currentMaskState,
int minibatchSize) |
Map<String,INDArray> |
BaseWrapperLayer.paramTable() |
Map<String,INDArray> |
BaseWrapperLayer.paramTable(boolean backpropParamsOnly) |
| Modifier and Type | Method and Description |
|---|---|
INDArray |
BaseWrapperLayer.activate(INDArray input,
boolean training,
LayerWorkspaceMgr workspaceMgr) |
Pair<Gradient,INDArray> |
BaseWrapperLayer.backpropGradient(INDArray epsilon,
LayerWorkspaceMgr workspaceMgr) |
Pair<INDArray,MaskState> |
BaseWrapperLayer.feedForwardMaskArray(INDArray maskArray,
MaskState currentMaskState,
int minibatchSize) |
void |
BaseWrapperLayer.fit(INDArray data,
LayerWorkspaceMgr workspaceMgr) |
void |
BaseWrapperLayer.setBackpropGradientsViewArray(INDArray gradients) |
void |
BaseWrapperLayer.setInput(INDArray input,
LayerWorkspaceMgr workspaceMgr) |
void |
BaseWrapperLayer.setMaskArray(INDArray maskArray) |
void |
BaseWrapperLayer.setParam(String key,
INDArray val) |
void |
BaseWrapperLayer.setParams(INDArray params) |
void |
BaseWrapperLayer.setParamsViewArray(INDArray params) |
void |
BaseWrapperLayer.update(INDArray gradient,
String paramType) |
| Modifier and Type | Method and Description |
|---|---|
void |
BaseWrapperLayer.setParamTable(Map<String,INDArray> paramTable) |
| Modifier and Type | Method and Description |
|---|---|
protected INDArray |
ModelTupleStream.getInputsFromTuple(org.apache.solr.client.solrj.io.Tuple tuple) |
| Modifier and Type | Method and Description |
|---|---|
protected org.apache.solr.client.solrj.io.Tuple |
ModelTupleStream.applyOutputsToTuple(org.apache.solr.client.solrj.io.Tuple tuple,
INDArray output) |
| Modifier and Type | Field and Description |
|---|---|
protected Map<String,INDArray> |
KerasLayer.weights |
| Modifier and Type | Method and Description |
|---|---|
INDArray |
Hdf5Archive.readDataSet(String datasetName,
String... groups)
Read data set as ND4J array from group path.
|
| Modifier and Type | Method and Description |
|---|---|
Map<String,INDArray> |
KerasLayer.getWeights() |
| Modifier and Type | Method and Description |
|---|---|
void |
KerasLayer.setWeights(Map<String,INDArray> weights)
Set weights for Keras layer.
|
| Modifier and Type | Method and Description |
|---|---|
void |
KerasPReLU.setWeights(Map<String,INDArray> weights)
Set weights for layer.
|
| Modifier and Type | Method and Description |
|---|---|
INDArray |
KerasConvolution.getConvParameterValues(INDArray kerasParamValue)
Return processed parameter values obtained from Keras convolutional layers.
|
| Modifier and Type | Method and Description |
|---|---|
INDArray |
KerasConvolution.getConvParameterValues(INDArray kerasParamValue)
Return processed parameter values obtained from Keras convolutional layers.
|
| Modifier and Type | Method and Description |
|---|---|
void |
KerasSeparableConvolution2D.setWeights(Map<String,INDArray> weights)
Set weights for layer.
|
void |
KerasDepthwiseConvolution2D.setWeights(Map<String,INDArray> weights)
Set weights for layer.
|
void |
KerasConvolution1D.setWeights(Map<String,INDArray> weights)
Set weights for layer.
|
void |
KerasConvolution.setWeights(Map<String,INDArray> weights)
Set weights for layer.
|
| Modifier and Type | Method and Description |
|---|---|
void |
KerasDense.setWeights(Map<String,INDArray> weights)
Set weights for layer.
|
| Modifier and Type | Method and Description |
|---|---|
void |
KerasEmbedding.setWeights(Map<String,INDArray> weights)
Set weights for layer.
|
| Modifier and Type | Method and Description |
|---|---|
void |
KerasLocallyConnected2D.setWeights(Map<String,INDArray> weights)
Set weights for 2D locally connected layer.
|
void |
KerasLocallyConnected1D.setWeights(Map<String,INDArray> weights)
Set weights for 1D locally connected layer.
|
| Modifier and Type | Method and Description |
|---|---|
void |
KerasBatchNormalization.setWeights(Map<String,INDArray> weights)
Set weights for layer.
|
| Modifier and Type | Method and Description |
|---|---|
void |
KerasSimpleRnn.setWeights(Map<String,INDArray> weights)
Set weights for layer.
|
void |
KerasLSTM.setWeights(Map<String,INDArray> weights)
Set weights for layer.
|
| Modifier and Type | Method and Description |
|---|---|
void |
KerasBidirectional.setWeights(Map<String,INDArray> weights)
Set weights for Bidirectional layer.
|
| Modifier and Type | Method and Description |
|---|---|
Pair<INDArray,INDArray> |
TimeSeriesGenerator.next(int index) |
Pair<INDArray,INDArray> |
TimeSeriesGenerator.next(int index) |
| Constructor and Description |
|---|
TimeSeriesGenerator(INDArray data,
INDArray targets,
int length) |
TimeSeriesGenerator(INDArray data,
INDArray targets,
int length,
int samplingRate,
int stride,
Integer startIndex,
Integer endIndex,
boolean shuffle,
boolean reverse,
int batchSize) |
| Modifier and Type | Method and Description |
|---|---|
INDArray |
KerasTokenizer.sequencesToMatrix(Integer[][] sequences,
TokenizerMode mode)
Turns an array of index sequences into an ND4J matrix of shape
(number of texts, number of words in vocabulary)
|
INDArray |
KerasTokenizer.textsToMatrix(String[] texts,
TokenizerMode mode)
Turns an array of texts into an ND4J matrix of shape
(number of texts, number of words in vocabulary)
|
| Modifier and Type | Method and Description |
|---|---|
INDArray |
TensorFlowCnnToFeedForwardPreProcessor.backprop(INDArray epsilons,
int miniBatchSize,
LayerWorkspaceMgr workspaceMgr) |
INDArray |
ReshapePreprocessor.backprop(INDArray output,
int miniBatchSize,
LayerWorkspaceMgr workspaceMgr) |
INDArray |
PermutePreprocessor.backprop(INDArray output,
int miniBatchSize,
LayerWorkspaceMgr workspaceMgr) |
INDArray |
KerasFlattenRnnPreprocessor.backprop(INDArray epsilons,
int miniBatchSize,
LayerWorkspaceMgr workspaceMgr) |
INDArray |
TensorFlowCnnToFeedForwardPreProcessor.preProcess(INDArray input,
int miniBatchSize,
LayerWorkspaceMgr workspaceMgr) |
INDArray |
ReshapePreprocessor.preProcess(INDArray input,
int miniBatchSize,
LayerWorkspaceMgr workspaceMgr) |
INDArray |
PermutePreprocessor.preProcess(INDArray input,
int miniBatchSize,
LayerWorkspaceMgr workspaceMgr) |
INDArray |
KerasFlattenRnnPreprocessor.preProcess(INDArray input,
int miniBatchSize,
LayerWorkspaceMgr workspaceMgr) |
| Modifier and Type | Method and Description |
|---|---|
INDArray |
TensorFlowCnnToFeedForwardPreProcessor.backprop(INDArray epsilons,
int miniBatchSize,
LayerWorkspaceMgr workspaceMgr) |
INDArray |
ReshapePreprocessor.backprop(INDArray output,
int miniBatchSize,
LayerWorkspaceMgr workspaceMgr) |
INDArray |
PermutePreprocessor.backprop(INDArray output,
int miniBatchSize,
LayerWorkspaceMgr workspaceMgr) |
INDArray |
KerasFlattenRnnPreprocessor.backprop(INDArray epsilons,
int miniBatchSize,
LayerWorkspaceMgr workspaceMgr) |
INDArray |
TensorFlowCnnToFeedForwardPreProcessor.preProcess(INDArray input,
int miniBatchSize,
LayerWorkspaceMgr workspaceMgr) |
INDArray |
ReshapePreprocessor.preProcess(INDArray input,
int miniBatchSize,
LayerWorkspaceMgr workspaceMgr) |
INDArray |
PermutePreprocessor.preProcess(INDArray input,
int miniBatchSize,
LayerWorkspaceMgr workspaceMgr) |
INDArray |
KerasFlattenRnnPreprocessor.preProcess(INDArray input,
int miniBatchSize,
LayerWorkspaceMgr workspaceMgr) |
| Modifier and Type | Method and Description |
|---|---|
static void |
KerasLayerUtils.removeDefaultWeights(Map<String,INDArray> weights,
KerasLayerConfiguration conf)
Remove weights from config after weight setting.
|
| Modifier and Type | Field and Description |
|---|---|
protected INDArray |
MultiLayerNetwork.flattenedGradients |
protected INDArray |
MultiLayerNetwork.flattenedParams |
protected INDArray |
MultiLayerNetwork.input |
protected INDArray |
MultiLayerNetwork.labels |
protected INDArray |
MultiLayerNetwork.mask |
| Modifier and Type | Method and Description |
|---|---|
INDArray |
MultiLayerNetwork.activate(boolean training,
LayerWorkspaceMgr mgr) |
INDArray |
MultiLayerNetwork.activate(INDArray input,
boolean training,
LayerWorkspaceMgr mgr) |
INDArray |
MultiLayerNetwork.activate(INDArray input,
Layer.TrainingMode training)
Equivalent to
#output(INDArray, TrainingMode) |
INDArray |
MultiLayerNetwork.activate(Layer.TrainingMode training)
Equivalent to
MultiLayerNetwork.output(INDArray) using the input set via MultiLayerNetwork.setInput(INDArray) |
INDArray |
MultiLayerNetwork.activateSelectedLayers(int from,
int to,
INDArray input)
Calculate activation for few layers at once.
|
protected INDArray |
MultiLayerNetwork.activationFromPrevLayer(int curr,
INDArray input,
boolean training,
LayerWorkspaceMgr mgr) |
INDArray |
MultiLayerNetwork.getGradientsViewArray() |
INDArray |
MultiLayerNetwork.getInput() |
INDArray |
MultiLayerNetwork.getLabels() |
INDArray |
MultiLayerNetwork.getMask() |
INDArray |
MultiLayerNetwork.getMaskArray() |
INDArray |
MultiLayerNetwork.getParam(String param)
Get one parameter array for the network.
|
INDArray |
MultiLayerNetwork.input() |
INDArray |
MultiLayerNetwork.output(DataSetIterator iterator)
Equivalent to
MultiLayerNetwork.output(DataSetIterator, boolean) with train=false |
INDArray |
MultiLayerNetwork.output(DataSetIterator iterator,
boolean train)
Generate the output for all examples/batches in the input iterator, and concatenate them into a single array.
|
INDArray |
MultiLayerNetwork.output(INDArray input)
Perform inference on the provided input/features - i.e., perform forward pass using the provided input/features
and return the output of the final layer.
|
INDArray |
MultiLayerNetwork.output(INDArray input,
boolean train)
Perform inference on the provided input/features - i.e., perform forward pass using the provided input/features
and return the output of the final layer.
|
INDArray |
MultiLayerNetwork.output(INDArray input,
boolean train,
INDArray featuresMask,
INDArray labelsMask)
Calculate the output of the network, with masking arrays.
|
INDArray |
MultiLayerNetwork.output(INDArray input,
boolean train,
INDArray featuresMask,
INDArray labelsMask,
MemoryWorkspace outputWorkspace)
Get the network output, which is optionally placed in the specified memory workspace.
|
INDArray |
MultiLayerNetwork.output(INDArray input,
boolean train,
MemoryWorkspace outputWorkspace)
Get the network output, which is optionally placed in the specified memory workspace.
|
INDArray |
MultiLayerNetwork.output(INDArray input,
Layer.TrainingMode train)
Perform inference on the provided input/features - i.e., perform forward pass using the provided input/features
and return the output of the final layer.
|
protected INDArray |
MultiLayerNetwork.outputOfLayerDetached(boolean train,
FwdPassType fwdPassType,
int layerIndex,
INDArray input,
INDArray featureMask,
INDArray labelsMask,
MemoryWorkspace outputWorkspace)
Provide the output of the specified layer, detached from any workspace.
|
INDArray |
MultiLayerNetwork.params()
Returns a 1 x m vector where the vector is composed of a flattened vector of all of the parameters in the network.
|
INDArray |
MultiLayerNetwork.params(boolean backwardOnly)
Deprecated.
To be removed. Use
MultiLayerNetwork.params() instead |
INDArray |
MultiLayerNetwork.rnnTimeStep(INDArray input)
If this MultiLayerNetwork contains one or more RNN layers: conduct forward pass (prediction)
but using previous stored state for any RNN layers.
|
INDArray |
MultiLayerNetwork.rnnTimeStep(INDArray input,
MemoryWorkspace outputWorkspace)
See
MultiLayerNetwork.rnnTimeStep(INDArray) for detailsIf no memory workspace is provided, the output will be detached (not in any workspace). |
INDArray |
MultiLayerNetwork.scoreExamples(DataSet data,
boolean addRegularizationTerms)
Calculate the score for each example in a DataSet individually.
|
INDArray |
MultiLayerNetwork.scoreExamples(DataSetIterator iter,
boolean addRegularizationTerms)
As per
MultiLayerNetwork.scoreExamples(DataSet, boolean) - the outputs (example scores) for all DataSets in the iterator are concatenated |
INDArray |
MultiLayerNetwork.updaterState() |
| Modifier and Type | Method and Description |
|---|---|
Pair<Gradient,INDArray> |
MultiLayerNetwork.backpropGradient(INDArray epsilon,
LayerWorkspaceMgr workspaceMgr) |
protected Pair<Gradient,INDArray> |
MultiLayerNetwork.calcBackpropGradients(INDArray epsilon,
boolean withOutputLayer,
boolean tbptt,
boolean returnInputActGrad)
Calculate gradients and errors.
|
Pair<Gradient,INDArray> |
MultiLayerNetwork.calculateGradients(INDArray features,
INDArray label,
INDArray fMask,
INDArray labelMask)
Calculate parameter gradients and input activation gradients given the input and labels, and optionally mask arrays
|
List<INDArray> |
MultiLayerNetwork.feedForward()
Compute activations of all layers from input (inclusive) to output of the final/output layer.
|
List<INDArray> |
MultiLayerNetwork.feedForward(boolean train)
Compute activations from input to output of the output layer.
|
List<INDArray> |
MultiLayerNetwork.feedForward(boolean train,
boolean clearInputs)
Perform feed-forward, optionally (not) clearing the layer input arrays.
|
List<INDArray> |
MultiLayerNetwork.feedForward(INDArray input)
Compute activations of all layers from input (inclusive) to output of the final/output layer.
|
List<INDArray> |
MultiLayerNetwork.feedForward(INDArray input,
boolean train)
Compute all layer activations, from input to output of the output layer.
|
List<INDArray> |
MultiLayerNetwork.feedForward(INDArray input,
INDArray featuresMask,
INDArray labelsMask)
Compute the activations from the input to the output layer, given mask arrays (that may be null)
The masking arrays are used in situations such an one-to-many and many-to-one rucerrent neural network (RNN)
designs, as well as for supporting time series of varying lengths within the same minibatch for RNNs.
|
Pair<INDArray,MaskState> |
MultiLayerNetwork.feedForwardMaskArray(INDArray maskArray,
MaskState currentMaskState,
int minibatchSize) |
List<INDArray> |
MultiLayerNetwork.feedForwardToLayer(int layerNum,
boolean train)
Compute the activations from the input to the specified layer, using the currently set input for the network.
|
List<INDArray> |
MultiLayerNetwork.feedForwardToLayer(int layerNum,
INDArray input)
Compute the activations from the input to the specified layer.
|
List<INDArray> |
MultiLayerNetwork.feedForwardToLayer(int layerNum,
INDArray input,
boolean train)
Compute the activations from the input to the specified layer.
|
protected List<INDArray> |
MultiLayerNetwork.ffToLayerActivationsDetached(boolean train,
FwdPassType fwdPassType,
boolean storeLastForTBPTT,
int layerIndex,
INDArray input,
INDArray fMask,
INDArray lMask,
boolean clearInputs)
Feed-forward through the network - returning all array activations in a list, detached from any workspace.
|
protected List<INDArray> |
MultiLayerNetwork.ffToLayerActivationsInWs(int layerIndex,
FwdPassType fwdPassType,
boolean storeLastForTBPTT,
INDArray input,
INDArray fMask,
INDArray lMask)
Feed-forward through the network at training time - returning a list of all activations in a workspace (WS_ALL_LAYERS_ACT)
if workspaces are enabled for training; or detached if no workspaces are used.
|
Map<String,INDArray> |
MultiLayerNetwork.paramTable()
Return a map of all parameters in the network.
|
Map<String,INDArray> |
MultiLayerNetwork.paramTable(boolean backpropParamsOnly)
Returns a map of all parameters in the network as per
MultiLayerNetwork.paramTable(). |
List<INDArray> |
MultiLayerNetwork.rnnActivateUsingStoredState(INDArray input,
boolean training,
boolean storeLastForTBPTT)
Similar to rnnTimeStep and feedForward() methods.
|
Map<String,INDArray> |
MultiLayerNetwork.rnnGetPreviousState(int layer)
Get the state of the RNN layer, as used in rnnTimeStep().
|
| Modifier and Type | Method and Description |
|---|---|
INDArray |
MultiLayerNetwork.activate(INDArray input,
boolean training,
LayerWorkspaceMgr mgr) |
INDArray |
MultiLayerNetwork.activate(INDArray input,
Layer.TrainingMode training)
Equivalent to
#output(INDArray, TrainingMode) |
INDArray |
MultiLayerNetwork.activateSelectedLayers(int from,
int to,
INDArray input)
Calculate activation for few layers at once.
|
protected INDArray |
MultiLayerNetwork.activationFromPrevLayer(int curr,
INDArray input,
boolean training,
LayerWorkspaceMgr mgr) |
Pair<Gradient,INDArray> |
MultiLayerNetwork.backpropGradient(INDArray epsilon,
LayerWorkspaceMgr workspaceMgr) |
protected Pair<Gradient,INDArray> |
MultiLayerNetwork.calcBackpropGradients(INDArray epsilon,
boolean withOutputLayer,
boolean tbptt,
boolean returnInputActGrad)
Calculate gradients and errors.
|
Pair<Gradient,INDArray> |
MultiLayerNetwork.calculateGradients(INDArray features,
INDArray label,
INDArray fMask,
INDArray labelMask)
Calculate parameter gradients and input activation gradients given the input and labels, and optionally mask arrays
|
protected void |
MultiLayerNetwork.doTruncatedBPTT(INDArray input,
INDArray labels,
INDArray featuresMaskArray,
INDArray labelsMaskArray,
LayerWorkspaceMgr workspaceMgr) |
double |
MultiLayerNetwork.f1Score(INDArray input,
INDArray labels)
Perform inference and then calculate the F1 score of the output(input) vs. the labels.
|
List<INDArray> |
MultiLayerNetwork.feedForward(INDArray input)
Compute activations of all layers from input (inclusive) to output of the final/output layer.
|
List<INDArray> |
MultiLayerNetwork.feedForward(INDArray input,
boolean train)
Compute all layer activations, from input to output of the output layer.
|
List<INDArray> |
MultiLayerNetwork.feedForward(INDArray input,
INDArray featuresMask,
INDArray labelsMask)
Compute the activations from the input to the output layer, given mask arrays (that may be null)
The masking arrays are used in situations such an one-to-many and many-to-one rucerrent neural network (RNN)
designs, as well as for supporting time series of varying lengths within the same minibatch for RNNs.
|
Pair<INDArray,MaskState> |
MultiLayerNetwork.feedForwardMaskArray(INDArray maskArray,
MaskState currentMaskState,
int minibatchSize) |
List<INDArray> |
MultiLayerNetwork.feedForwardToLayer(int layerNum,
INDArray input)
Compute the activations from the input to the specified layer.
|
List<INDArray> |
MultiLayerNetwork.feedForwardToLayer(int layerNum,
INDArray input,
boolean train)
Compute the activations from the input to the specified layer.
|
protected List<INDArray> |
MultiLayerNetwork.ffToLayerActivationsDetached(boolean train,
FwdPassType fwdPassType,
boolean storeLastForTBPTT,
int layerIndex,
INDArray input,
INDArray fMask,
INDArray lMask,
boolean clearInputs)
Feed-forward through the network - returning all array activations in a list, detached from any workspace.
|
protected List<INDArray> |
MultiLayerNetwork.ffToLayerActivationsInWs(int layerIndex,
FwdPassType fwdPassType,
boolean storeLastForTBPTT,
INDArray input,
INDArray fMask,
INDArray lMask)
Feed-forward through the network at training time - returning a list of all activations in a workspace (WS_ALL_LAYERS_ACT)
if workspaces are enabled for training; or detached if no workspaces are used.
|
void |
MultiLayerNetwork.fit(INDArray data,
INDArray labels)
Fit the model for one iteration on the provided data
|
void |
MultiLayerNetwork.fit(INDArray features,
INDArray labels,
INDArray featuresMask,
INDArray labelsMask)
Fit the model for one iteration on the provided data
|
void |
MultiLayerNetwork.fit(INDArray examples,
int[] labels)
Fit the model for one iteration on the provided data
|
void |
MultiLayerNetwork.fit(INDArray data,
LayerWorkspaceMgr workspaceMgr) |
void |
MultiLayerNetwork.init(INDArray parameters,
boolean cloneParametersArray)
Initialize the MultiLayerNetwork, optionally with an existing parameters array.
|
INDArray |
MultiLayerNetwork.output(INDArray input)
Perform inference on the provided input/features - i.e., perform forward pass using the provided input/features
and return the output of the final layer.
|
INDArray |
MultiLayerNetwork.output(INDArray input,
boolean train)
Perform inference on the provided input/features - i.e., perform forward pass using the provided input/features
and return the output of the final layer.
|
INDArray |
MultiLayerNetwork.output(INDArray input,
boolean train,
INDArray featuresMask,
INDArray labelsMask)
Calculate the output of the network, with masking arrays.
|
INDArray |
MultiLayerNetwork.output(INDArray input,
boolean train,
INDArray featuresMask,
INDArray labelsMask,
MemoryWorkspace outputWorkspace)
Get the network output, which is optionally placed in the specified memory workspace.
|
INDArray |
MultiLayerNetwork.output(INDArray input,
boolean train,
MemoryWorkspace outputWorkspace)
Get the network output, which is optionally placed in the specified memory workspace.
|
<T> T |
MultiLayerNetwork.output(INDArray inputs,
INDArray inputMasks,
INDArray labelMasks,
OutputAdapter<T> outputAdapter)
This method uses provided OutputAdapter to return custom object built from INDArray
PLEASE NOTE: This method uses dedicated Workspace for output generation to avoid redundant allocations
|
INDArray |
MultiLayerNetwork.output(INDArray input,
Layer.TrainingMode train)
Perform inference on the provided input/features - i.e., perform forward pass using the provided input/features
and return the output of the final layer.
|
protected INDArray |
MultiLayerNetwork.outputOfLayerDetached(boolean train,
FwdPassType fwdPassType,
int layerIndex,
INDArray input,
INDArray featureMask,
INDArray labelsMask,
MemoryWorkspace outputWorkspace)
Provide the output of the specified layer, detached from any workspace.
|
int[] |
MultiLayerNetwork.predict(INDArray d)
Usable only for classification networks in conjunction with OutputLayer.
|
void |
MultiLayerNetwork.pretrainLayer(int layerIdx,
INDArray features)
Perform layerwise unsupervised training on a single pre-trainable layer in the network (VAEs, Autoencoders, etc)
If the specified layer index (0 to numLayers - 1) is not a pretrainable layer, this is a no-op. |
List<INDArray> |
MultiLayerNetwork.rnnActivateUsingStoredState(INDArray input,
boolean training,
boolean storeLastForTBPTT)
Similar to rnnTimeStep and feedForward() methods.
|
INDArray |
MultiLayerNetwork.rnnTimeStep(INDArray input)
If this MultiLayerNetwork contains one or more RNN layers: conduct forward pass (prediction)
but using previous stored state for any RNN layers.
|
INDArray |
MultiLayerNetwork.rnnTimeStep(INDArray input,
MemoryWorkspace outputWorkspace)
See
MultiLayerNetwork.rnnTimeStep(INDArray) for detailsIf no memory workspace is provided, the output will be detached (not in any workspace). |
void |
MultiLayerNetwork.setBackpropGradientsViewArray(INDArray gradients) |
void |
MultiLayerNetwork.setInput(INDArray input)
Set the input array for the network
|
void |
MultiLayerNetwork.setInput(INDArray input,
LayerWorkspaceMgr mgr) |
void |
MultiLayerNetwork.setLabels(INDArray labels) |
void |
MultiLayerNetwork.setLayerMaskArrays(INDArray featuresMaskArray,
INDArray labelsMaskArray)
Set the mask arrays for features and labels.
|
void |
MultiLayerNetwork.setMask(INDArray mask) |
void |
MultiLayerNetwork.setMaskArray(INDArray maskArray) |
void |
MultiLayerNetwork.setParam(String key,
INDArray val)
Set the values of a single parameter.
|
void |
MultiLayerNetwork.setParameters(INDArray params)
|
void |
MultiLayerNetwork.setParams(INDArray params)
Set the parameters for this model.
|
void |
MultiLayerNetwork.setParamsViewArray(INDArray params) |
void |
MultiLayerNetwork.update(INDArray gradient,
String paramType) |
protected void |
MultiLayerNetwork.validateArrayWorkspaces(LayerWorkspaceMgr mgr,
INDArray array,
ArrayType arrayType,
int layerIdx,
boolean isPreprocessor,
String op) |
| Modifier and Type | Method and Description |
|---|---|
void |
MultiLayerNetwork.rnnSetPreviousState(int layer,
Map<String,INDArray> state)
Set the state of the RNN layer.
|
void |
MultiLayerNetwork.setParamTable(Map<String,INDArray> paramTable)
Set the parameters of the netowrk.
|
| Constructor and Description |
|---|
MultiLayerNetwork(MultiLayerConfiguration conf,
INDArray params)
Initialize the network based on the configuration and parameters array
|
MultiLayerNetwork(String conf,
INDArray params)
Initialize the network based on the configuration (a MultiLayerConfiguration in JSON format) and parameters array
|
| Modifier and Type | Method and Description |
|---|---|
protected INDArray |
DefaultParamInitializer.createBias(long nOut,
double biasInit,
INDArray biasParamView,
boolean initializeParameters) |
protected INDArray |
SeparableConvolutionParamInitializer.createBias(NeuralNetConfiguration conf,
INDArray biasView,
boolean initializeParams) |
protected INDArray |
DepthwiseConvolutionParamInitializer.createBias(NeuralNetConfiguration conf,
INDArray biasView,
boolean initializeParams) |
protected INDArray |
DefaultParamInitializer.createBias(NeuralNetConfiguration conf,
INDArray biasParamView,
boolean initializeParameters) |
protected INDArray |
ConvolutionParamInitializer.createBias(NeuralNetConfiguration conf,
INDArray biasView,
boolean initializeParams) |
protected INDArray |
CenterLossParamInitializer.createCenterLossMatrix(NeuralNetConfiguration conf,
INDArray centerLossView,
boolean initializeParameters) |
protected INDArray |
SeparableConvolutionParamInitializer.createDepthWiseWeightMatrix(NeuralNetConfiguration conf,
INDArray weightView,
boolean initializeParams) |
protected INDArray |
DepthwiseConvolutionParamInitializer.createDepthWiseWeightMatrix(NeuralNetConfiguration conf,
INDArray weightView,
boolean initializeParams) |
protected INDArray |
DefaultParamInitializer.createGain(long nOut,
double gainInit,
INDArray gainParamView,
boolean initializeParameters) |
protected INDArray |
DefaultParamInitializer.createGain(NeuralNetConfiguration conf,
INDArray gainParamView,
boolean initializeParameters) |
protected INDArray |
SeparableConvolutionParamInitializer.createPointWiseWeightMatrix(NeuralNetConfiguration conf,
INDArray weightView,
boolean initializeParams) |
protected INDArray |
PretrainParamInitializer.createVisibleBias(NeuralNetConfiguration conf,
INDArray visibleBiasView,
boolean initializeParameters) |
protected INDArray |
ElementWiseParamInitializer.createWeightMatrix(long nIn,
long nOut,
IWeightInit weightInit,
INDArray weightParamView,
boolean initializeParameters) |
protected INDArray |
DefaultParamInitializer.createWeightMatrix(long nIn,
long nOut,
IWeightInit weightInit,
INDArray weightParamView,
boolean initializeParameters) |
protected INDArray |
PReLUParamInitializer.createWeightMatrix(NeuralNetConfiguration conf,
INDArray weightParamView,
boolean initializeParameters) |
protected INDArray |
DefaultParamInitializer.createWeightMatrix(NeuralNetConfiguration conf,
INDArray weightParamView,
boolean initializeParameters) |
protected INDArray |
DeconvolutionParamInitializer.createWeightMatrix(NeuralNetConfiguration conf,
INDArray weightView,
boolean initializeParams) |
protected INDArray |
ConvolutionParamInitializer.createWeightMatrix(NeuralNetConfiguration conf,
INDArray weightView,
boolean initializeParams) |
protected INDArray |
Convolution3DParamInitializer.createWeightMatrix(NeuralNetConfiguration conf,
INDArray weightView,
boolean initializeParams) |
| Modifier and Type | Method and Description |
|---|---|
Map<String,INDArray> |
WrapperLayerParamInitializer.getGradientsFromFlattened(NeuralNetConfiguration conf,
INDArray gradientView) |
Map<String,INDArray> |
VariationalAutoencoderParamInitializer.getGradientsFromFlattened(NeuralNetConfiguration conf,
INDArray gradientView) |
Map<String,INDArray> |
SimpleRnnParamInitializer.getGradientsFromFlattened(NeuralNetConfiguration conf,
INDArray gradientView) |
Map<String,INDArray> |
SeparableConvolutionParamInitializer.getGradientsFromFlattened(NeuralNetConfiguration conf,
INDArray gradientView) |
Map<String,INDArray> |
SameDiffParamInitializer.getGradientsFromFlattened(NeuralNetConfiguration conf,
INDArray gradientView) |
Map<String,INDArray> |
PretrainParamInitializer.getGradientsFromFlattened(NeuralNetConfiguration conf,
INDArray gradientView) |
Map<String,INDArray> |
PReLUParamInitializer.getGradientsFromFlattened(NeuralNetConfiguration conf,
INDArray gradientView) |
Map<String,INDArray> |
LSTMParamInitializer.getGradientsFromFlattened(NeuralNetConfiguration conf,
INDArray gradientView) |
Map<String,INDArray> |
GravesLSTMParamInitializer.getGradientsFromFlattened(NeuralNetConfiguration conf,
INDArray gradientView) |
Map<String,INDArray> |
GravesBidirectionalLSTMParamInitializer.getGradientsFromFlattened(NeuralNetConfiguration conf,
INDArray gradientView) |
Map<String,INDArray> |
FrozenLayerWithBackpropParamInitializer.getGradientsFromFlattened(NeuralNetConfiguration conf,
INDArray gradientView) |
Map<String,INDArray> |
FrozenLayerParamInitializer.getGradientsFromFlattened(NeuralNetConfiguration conf,
INDArray gradientView) |
Map<String,INDArray> |
EmptyParamInitializer.getGradientsFromFlattened(NeuralNetConfiguration conf,
INDArray gradientView) |
Map<String,INDArray> |
ElementWiseParamInitializer.getGradientsFromFlattened(NeuralNetConfiguration conf,
INDArray gradientView)
Return a map of gradients (in their standard non-flattened representation), taken from the flattened (row vector) gradientView array.
|
Map<String,INDArray> |
DepthwiseConvolutionParamInitializer.getGradientsFromFlattened(NeuralNetConfiguration conf,
INDArray gradientView) |
Map<String,INDArray> |
DefaultParamInitializer.getGradientsFromFlattened(NeuralNetConfiguration conf,
INDArray gradientView) |
Map<String,INDArray> |
DeconvolutionParamInitializer.getGradientsFromFlattened(NeuralNetConfiguration conf,
INDArray gradientView) |
Map<String,INDArray> |
ConvolutionParamInitializer.getGradientsFromFlattened(NeuralNetConfiguration conf,
INDArray gradientView) |
Map<String,INDArray> |
Convolution3DParamInitializer.getGradientsFromFlattened(NeuralNetConfiguration conf,
INDArray gradientView) |
Map<String,INDArray> |
CenterLossParamInitializer.getGradientsFromFlattened(NeuralNetConfiguration conf,
INDArray gradientView) |
Map<String,INDArray> |
BidirectionalParamInitializer.getGradientsFromFlattened(NeuralNetConfiguration conf,
INDArray gradientView) |
Map<String,INDArray> |
BatchNormalizationParamInitializer.getGradientsFromFlattened(NeuralNetConfiguration conf,
INDArray gradientView) |
Map<String,INDArray> |
WrapperLayerParamInitializer.init(NeuralNetConfiguration conf,
INDArray paramsView,
boolean initializeParams) |
Map<String,INDArray> |
VariationalAutoencoderParamInitializer.init(NeuralNetConfiguration conf,
INDArray paramsView,
boolean initializeParams) |
Map<String,INDArray> |
SimpleRnnParamInitializer.init(NeuralNetConfiguration conf,
INDArray paramsView,
boolean initializeParams) |
Map<String,INDArray> |
SeparableConvolutionParamInitializer.init(NeuralNetConfiguration conf,
INDArray paramsView,
boolean initializeParams) |
Map<String,INDArray> |
SameDiffParamInitializer.init(NeuralNetConfiguration conf,
INDArray paramsView,
boolean initializeParams) |
Map<String,INDArray> |
PretrainParamInitializer.init(NeuralNetConfiguration conf,
INDArray paramsView,
boolean initializeParams) |
Map<String,INDArray> |
PReLUParamInitializer.init(NeuralNetConfiguration conf,
INDArray paramsView,
boolean initializeParams) |
Map<String,INDArray> |
LSTMParamInitializer.init(NeuralNetConfiguration conf,
INDArray paramsView,
boolean initializeParams) |
Map<String,INDArray> |
GravesLSTMParamInitializer.init(NeuralNetConfiguration conf,
INDArray paramsView,
boolean initializeParams) |
Map<String,INDArray> |
GravesBidirectionalLSTMParamInitializer.init(NeuralNetConfiguration conf,
INDArray paramsView,
boolean initializeParams) |
Map<String,INDArray> |
FrozenLayerWithBackpropParamInitializer.init(NeuralNetConfiguration conf,
INDArray paramsView,
boolean initializeParams) |
Map<String,INDArray> |
FrozenLayerParamInitializer.init(NeuralNetConfiguration conf,
INDArray paramsView,
boolean initializeParams) |
Map<String,INDArray> |
EmptyParamInitializer.init(NeuralNetConfiguration conf,
INDArray paramsView,
boolean initializeParams) |
Map<String,INDArray> |
ElementWiseParamInitializer.init(NeuralNetConfiguration conf,
INDArray paramsView,
boolean initializeParams)
Initialize the parameters
|
Map<String,INDArray> |
DepthwiseConvolutionParamInitializer.init(NeuralNetConfiguration conf,
INDArray paramsView,
boolean initializeParams) |
Map<String,INDArray> |
DefaultParamInitializer.init(NeuralNetConfiguration conf,
INDArray paramsView,
boolean initializeParams) |
Map<String,INDArray> |
ConvolutionParamInitializer.init(NeuralNetConfiguration conf,
INDArray paramsView,
boolean initializeParams) |
Map<String,INDArray> |
Convolution3DParamInitializer.init(NeuralNetConfiguration conf,
INDArray paramsView,
boolean initializeParams) |
Map<String,INDArray> |
CenterLossParamInitializer.init(NeuralNetConfiguration conf,
INDArray paramsView,
boolean initializeParams) |
Map<String,INDArray> |
BidirectionalParamInitializer.init(NeuralNetConfiguration conf,
INDArray paramsView,
boolean initializeParams) |
Map<String,INDArray> |
BatchNormalizationParamInitializer.init(NeuralNetConfiguration conf,
INDArray paramView,
boolean initializeParams) |
Map<String,INDArray> |
SameDiffParamInitializer.subsetAndReshape(List<String> params,
Map<String,long[]> paramShapes,
INDArray view,
AbstractSameDiffLayer sdl,
SameDiffVertex sdv) |
| Modifier and Type | Method and Description |
|---|---|
protected INDArray |
DefaultParamInitializer.createBias(long nOut,
double biasInit,
INDArray biasParamView,
boolean initializeParameters) |
protected INDArray |
SeparableConvolutionParamInitializer.createBias(NeuralNetConfiguration conf,
INDArray biasView,
boolean initializeParams) |
protected INDArray |
DepthwiseConvolutionParamInitializer.createBias(NeuralNetConfiguration conf,
INDArray biasView,
boolean initializeParams) |
protected INDArray |
DefaultParamInitializer.createBias(NeuralNetConfiguration conf,
INDArray biasParamView,
boolean initializeParameters) |
protected INDArray |
ConvolutionParamInitializer.createBias(NeuralNetConfiguration conf,
INDArray biasView,
boolean initializeParams) |
protected INDArray |
CenterLossParamInitializer.createCenterLossMatrix(NeuralNetConfiguration conf,
INDArray centerLossView,
boolean initializeParameters) |
protected INDArray |
SeparableConvolutionParamInitializer.createDepthWiseWeightMatrix(NeuralNetConfiguration conf,
INDArray weightView,
boolean initializeParams) |
protected INDArray |
DepthwiseConvolutionParamInitializer.createDepthWiseWeightMatrix(NeuralNetConfiguration conf,
INDArray weightView,
boolean initializeParams) |
protected INDArray |
DefaultParamInitializer.createGain(long nOut,
double gainInit,
INDArray gainParamView,
boolean initializeParameters) |
protected INDArray |
DefaultParamInitializer.createGain(NeuralNetConfiguration conf,
INDArray gainParamView,
boolean initializeParameters) |
protected INDArray |
SeparableConvolutionParamInitializer.createPointWiseWeightMatrix(NeuralNetConfiguration conf,
INDArray weightView,
boolean initializeParams) |
protected INDArray |
PretrainParamInitializer.createVisibleBias(NeuralNetConfiguration conf,
INDArray visibleBiasView,
boolean initializeParameters) |
protected INDArray |
ElementWiseParamInitializer.createWeightMatrix(long nIn,
long nOut,
IWeightInit weightInit,
INDArray weightParamView,
boolean initializeParameters) |
protected INDArray |
DefaultParamInitializer.createWeightMatrix(long nIn,
long nOut,
IWeightInit weightInit,
INDArray weightParamView,
boolean initializeParameters) |
protected INDArray |
PReLUParamInitializer.createWeightMatrix(NeuralNetConfiguration conf,
INDArray weightParamView,
boolean initializeParameters) |
protected INDArray |
DefaultParamInitializer.createWeightMatrix(NeuralNetConfiguration conf,
INDArray weightParamView,
boolean initializeParameters) |
protected INDArray |
DeconvolutionParamInitializer.createWeightMatrix(NeuralNetConfiguration conf,
INDArray weightView,
boolean initializeParams) |
protected INDArray |
ConvolutionParamInitializer.createWeightMatrix(NeuralNetConfiguration conf,
INDArray weightView,
boolean initializeParams) |
protected INDArray |
Convolution3DParamInitializer.createWeightMatrix(NeuralNetConfiguration conf,
INDArray weightView,
boolean initializeParams) |
Map<String,INDArray> |
WrapperLayerParamInitializer.getGradientsFromFlattened(NeuralNetConfiguration conf,
INDArray gradientView) |
Map<String,INDArray> |
VariationalAutoencoderParamInitializer.getGradientsFromFlattened(NeuralNetConfiguration conf,
INDArray gradientView) |
Map<String,INDArray> |
SimpleRnnParamInitializer.getGradientsFromFlattened(NeuralNetConfiguration conf,
INDArray gradientView) |
Map<String,INDArray> |
SeparableConvolutionParamInitializer.getGradientsFromFlattened(NeuralNetConfiguration conf,
INDArray gradientView) |
Map<String,INDArray> |
SameDiffParamInitializer.getGradientsFromFlattened(NeuralNetConfiguration conf,
INDArray gradientView) |
Map<String,INDArray> |
PretrainParamInitializer.getGradientsFromFlattened(NeuralNetConfiguration conf,
INDArray gradientView) |
Map<String,INDArray> |
PReLUParamInitializer.getGradientsFromFlattened(NeuralNetConfiguration conf,
INDArray gradientView) |
Map<String,INDArray> |
LSTMParamInitializer.getGradientsFromFlattened(NeuralNetConfiguration conf,
INDArray gradientView) |
Map<String,INDArray> |
GravesLSTMParamInitializer.getGradientsFromFlattened(NeuralNetConfiguration conf,
INDArray gradientView) |
Map<String,INDArray> |
GravesBidirectionalLSTMParamInitializer.getGradientsFromFlattened(NeuralNetConfiguration conf,
INDArray gradientView) |
Map<String,INDArray> |
FrozenLayerWithBackpropParamInitializer.getGradientsFromFlattened(NeuralNetConfiguration conf,
INDArray gradientView) |
Map<String,INDArray> |
FrozenLayerParamInitializer.getGradientsFromFlattened(NeuralNetConfiguration conf,
INDArray gradientView) |
Map<String,INDArray> |
EmptyParamInitializer.getGradientsFromFlattened(NeuralNetConfiguration conf,
INDArray gradientView) |
Map<String,INDArray> |
ElementWiseParamInitializer.getGradientsFromFlattened(NeuralNetConfiguration conf,
INDArray gradientView)
Return a map of gradients (in their standard non-flattened representation), taken from the flattened (row vector) gradientView array.
|
Map<String,INDArray> |
DepthwiseConvolutionParamInitializer.getGradientsFromFlattened(NeuralNetConfiguration conf,
INDArray gradientView) |
Map<String,INDArray> |
DefaultParamInitializer.getGradientsFromFlattened(NeuralNetConfiguration conf,
INDArray gradientView) |
Map<String,INDArray> |
DeconvolutionParamInitializer.getGradientsFromFlattened(NeuralNetConfiguration conf,
INDArray gradientView) |
Map<String,INDArray> |
ConvolutionParamInitializer.getGradientsFromFlattened(NeuralNetConfiguration conf,
INDArray gradientView) |
Map<String,INDArray> |
Convolution3DParamInitializer.getGradientsFromFlattened(NeuralNetConfiguration conf,
INDArray gradientView) |
Map<String,INDArray> |
CenterLossParamInitializer.getGradientsFromFlattened(NeuralNetConfiguration conf,
INDArray gradientView) |
Map<String,INDArray> |
BidirectionalParamInitializer.getGradientsFromFlattened(NeuralNetConfiguration conf,
INDArray gradientView) |
Map<String,INDArray> |
BatchNormalizationParamInitializer.getGradientsFromFlattened(NeuralNetConfiguration conf,
INDArray gradientView) |
Map<String,INDArray> |
WrapperLayerParamInitializer.init(NeuralNetConfiguration conf,
INDArray paramsView,
boolean initializeParams) |
Map<String,INDArray> |
VariationalAutoencoderParamInitializer.init(NeuralNetConfiguration conf,
INDArray paramsView,
boolean initializeParams) |
Map<String,INDArray> |
SimpleRnnParamInitializer.init(NeuralNetConfiguration conf,
INDArray paramsView,
boolean initializeParams) |
Map<String,INDArray> |
SeparableConvolutionParamInitializer.init(NeuralNetConfiguration conf,
INDArray paramsView,
boolean initializeParams) |
Map<String,INDArray> |
SameDiffParamInitializer.init(NeuralNetConfiguration conf,
INDArray paramsView,
boolean initializeParams) |
Map<String,INDArray> |
PretrainParamInitializer.init(NeuralNetConfiguration conf,
INDArray paramsView,
boolean initializeParams) |
Map<String,INDArray> |
PReLUParamInitializer.init(NeuralNetConfiguration conf,
INDArray paramsView,
boolean initializeParams) |
Map<String,INDArray> |
LSTMParamInitializer.init(NeuralNetConfiguration conf,
INDArray paramsView,
boolean initializeParams) |
Map<String,INDArray> |
GravesLSTMParamInitializer.init(NeuralNetConfiguration conf,
INDArray paramsView,
boolean initializeParams) |
Map<String,INDArray> |
GravesBidirectionalLSTMParamInitializer.init(NeuralNetConfiguration conf,
INDArray paramsView,
boolean initializeParams) |
Map<String,INDArray> |
FrozenLayerWithBackpropParamInitializer.init(NeuralNetConfiguration conf,
INDArray paramsView,
boolean initializeParams) |
Map<String,INDArray> |
FrozenLayerParamInitializer.init(NeuralNetConfiguration conf,
INDArray paramsView,
boolean initializeParams) |
Map<String,INDArray> |
EmptyParamInitializer.init(NeuralNetConfiguration conf,
INDArray paramsView,
boolean initializeParams) |
Map<String,INDArray> |
ElementWiseParamInitializer.init(NeuralNetConfiguration conf,
INDArray paramsView,
boolean initializeParams)
Initialize the parameters
|
Map<String,INDArray> |
DepthwiseConvolutionParamInitializer.init(NeuralNetConfiguration conf,
INDArray paramsView,
boolean initializeParams) |
Map<String,INDArray> |
DefaultParamInitializer.init(NeuralNetConfiguration conf,
INDArray paramsView,
boolean initializeParams) |
Map<String,INDArray> |
ConvolutionParamInitializer.init(NeuralNetConfiguration conf,
INDArray paramsView,
boolean initializeParams) |
Map<String,INDArray> |
Convolution3DParamInitializer.init(NeuralNetConfiguration conf,
INDArray paramsView,
boolean initializeParams) |
Map<String,INDArray> |
CenterLossParamInitializer.init(NeuralNetConfiguration conf,
INDArray paramsView,
boolean initializeParams) |
Map<String,INDArray> |
BidirectionalParamInitializer.init(NeuralNetConfiguration conf,
INDArray paramsView,
boolean initializeParams) |
Map<String,INDArray> |
BatchNormalizationParamInitializer.init(NeuralNetConfiguration conf,
INDArray paramView,
boolean initializeParams) |
Map<String,INDArray> |
SameDiffParamInitializer.subsetAndReshape(List<String> params,
Map<String,long[]> paramShapes,
INDArray view,
AbstractSameDiffLayer sdl,
SameDiffVertex sdv) |
| Modifier and Type | Method and Description |
|---|---|
INDArray |
TransferLearningHelper.outputFromFeaturized(INDArray input)
Use to get the output from a featurized input
|
INDArray[] |
TransferLearningHelper.outputFromFeaturized(INDArray[] input)
Use to get the output from a featurized input
|
| Modifier and Type | Method and Description |
|---|---|
INDArray |
TransferLearningHelper.outputFromFeaturized(INDArray input)
Use to get the output from a featurized input
|
INDArray[] |
TransferLearningHelper.outputFromFeaturized(INDArray[] input)
Use to get the output from a featurized input
|
| Modifier and Type | Field and Description |
|---|---|
protected INDArray |
BaseMultiLayerUpdater.updaterStateViewArray |
| Modifier and Type | Field and Description |
|---|---|
protected List<INDArray> |
BaseMultiLayerUpdater.gradientsForMinibatchDivision |
| Modifier and Type | Method and Description |
|---|---|
protected INDArray |
MultiLayerUpdater.getFlattenedGradientsView() |
protected INDArray |
LayerUpdater.getFlattenedGradientsView() |
protected abstract INDArray |
BaseMultiLayerUpdater.getFlattenedGradientsView() |
protected INDArray |
MultiLayerUpdater.getParams() |
protected INDArray |
LayerUpdater.getParams() |
protected abstract INDArray |
BaseMultiLayerUpdater.getParams() |
INDArray |
BaseMultiLayerUpdater.getStateViewArray() |
INDArray |
BaseMultiLayerUpdater.getStateViewArrayCopy()
A synchronized version of
BaseMultiLayerUpdater.getStateViewArray() that duplicates the view array internally. |
| Modifier and Type | Method and Description |
|---|---|
protected List<INDArray> |
BaseMultiLayerUpdater.getMinibatchDivisionSubsets(INDArray from) |
| Modifier and Type | Method and Description |
|---|---|
protected void |
UpdaterBlock.applyRegularization(Regularization.ApplyStep step,
Trainable layer,
String paramName,
INDArray gradientView,
INDArray paramsView,
int iter,
int epoch,
double lr)
Apply L1 and L2 regularization, if necessary.
|
protected void |
UpdaterBlock.applyRegularizationAllVariables(Regularization.ApplyStep applyStep,
int iteration,
int epoch,
boolean externalGradient,
INDArray fullNetworkGradientView,
INDArray fullNetworkParamsArray) |
protected List<INDArray> |
BaseMultiLayerUpdater.getMinibatchDivisionSubsets(INDArray from) |
void |
BaseMultiLayerUpdater.setStateViewArray(INDArray viewArray)
Set the view array.
|
void |
BaseMultiLayerUpdater.setStateViewArray(Trainable layer,
INDArray viewArray,
boolean initialize) |
void |
UpdaterBlock.updateExternalGradient(int iteration,
int epoch,
INDArray fullNetworkGradientView,
INDArray fullNetworkParamsArray) |
| Constructor and Description |
|---|
BaseMultiLayerUpdater(T network,
INDArray updaterState) |
LayerUpdater(Layer layer,
INDArray updaterState) |
MultiLayerUpdater(MultiLayerNetwork network,
INDArray updaterState) |
| Modifier and Type | Method and Description |
|---|---|
protected INDArray |
ComputationGraphUpdater.getFlattenedGradientsView() |
protected INDArray |
ComputationGraphUpdater.getParams() |
| Constructor and Description |
|---|
ComputationGraphUpdater(ComputationGraph graph,
INDArray updaterState) |
| Modifier and Type | Method and Description |
|---|---|
INDArray |
WeightInitXavierUniform.init(double fanIn,
double fanOut,
long[] shape,
char order,
INDArray paramView) |
INDArray |
WeightInitXavierLegacy.init(double fanIn,
double fanOut,
long[] shape,
char order,
INDArray paramView) |
INDArray |
WeightInitXavier.init(double fanIn,
double fanOut,
long[] shape,
char order,
INDArray paramView) |
INDArray |
WeightInitVarScalingUniformFanOut.init(double fanIn,
double fanOut,
long[] shape,
char order,
INDArray paramView) |
INDArray |
WeightInitVarScalingUniformFanIn.init(double fanIn,
double fanOut,
long[] shape,
char order,
INDArray paramView) |
INDArray |
WeightInitVarScalingUniformFanAvg.init(double fanIn,
double fanOut,
long[] shape,
char order,
INDArray paramView) |
INDArray |
WeightInitVarScalingNormalFanOut.init(double fanIn,
double fanOut,
long[] shape,
char order,
INDArray paramView) |
INDArray |
WeightInitVarScalingNormalFanIn.init(double fanIn,
double fanOut,
long[] shape,
char order,
INDArray paramView) |
INDArray |
WeightInitVarScalingNormalFanAvg.init(double fanIn,
double fanOut,
long[] shape,
char order,
INDArray paramView) |
INDArray |
WeightInitUniform.init(double fanIn,
double fanOut,
long[] shape,
char order,
INDArray paramView) |
INDArray |
WeightInitSigmoidUniform.init(double fanIn,
double fanOut,
long[] shape,
char order,
INDArray paramView) |
INDArray |
WeightInitReluUniform.init(double fanIn,
double fanOut,
long[] shape,
char order,
INDArray paramView) |
INDArray |
WeightInitRelu.init(double fanIn,
double fanOut,
long[] shape,
char order,
INDArray paramView) |
INDArray |
WeightInitNormal.init(double fanIn,
double fanOut,
long[] shape,
char order,
INDArray paramView) |
INDArray |
WeightInitLecunUniform.init(double fanIn,
double fanOut,
long[] shape,
char order,
INDArray paramView) |
INDArray |
WeightInitIdentity.init(double fanIn,
double fanOut,
long[] shape,
char order,
INDArray paramView) |
INDArray |
WeightInitDistribution.init(double fanIn,
double fanOut,
long[] shape,
char order,
INDArray paramView) |
INDArray |
WeightInitConstant.init(double fanIn,
double fanOut,
long[] shape,
char order,
INDArray paramView) |
INDArray |
IWeightInit.init(double fanIn,
double fanOut,
long[] shape,
char order,
INDArray paramView)
Initialize parameters in the given view.
|
static INDArray |
WeightInitUtil.initWeights(double fanIn,
double fanOut,
int[] shape,
WeightInit initScheme,
Distribution dist,
char order,
INDArray paramView)
Deprecated.
|
static INDArray |
WeightInitUtil.initWeights(double fanIn,
double fanOut,
int[] shape,
WeightInit initScheme,
Distribution dist,
INDArray paramView)
Deprecated.
|
static INDArray |
WeightInitUtil.initWeights(double fanIn,
double fanOut,
long[] shape,
WeightInit initScheme,
Distribution dist,
char order,
INDArray paramView) |
static INDArray |
WeightInitUtil.initWeights(double fanIn,
double fanOut,
long[] shape,
WeightInit initScheme,
Distribution dist,
INDArray paramView)
Initializes a matrix with the given weight initialization scheme.
|
static INDArray |
WeightInitUtil.reshapeWeights(int[] shape,
INDArray paramsView)
Reshape the parameters view, without modifying the paramsView array values.
|
static INDArray |
WeightInitUtil.reshapeWeights(int[] shape,
INDArray paramsView,
char flatteningOrder)
Reshape the parameters view, without modifying the paramsView array values.
|
static INDArray |
WeightInitUtil.reshapeWeights(long[] shape,
INDArray paramsView)
Reshape the parameters view, without modifying the paramsView array values.
|
static INDArray |
WeightInitUtil.reshapeWeights(long[] shape,
INDArray paramsView,
char flatteningOrder)
Reshape the parameters view, without modifying the paramsView array values.
|
| Modifier and Type | Method and Description |
|---|---|
INDArray |
WeightInitXavierUniform.init(double fanIn,
double fanOut,
long[] shape,
char order,
INDArray paramView) |
INDArray |
WeightInitXavierLegacy.init(double fanIn,
double fanOut,
long[] shape,
char order,
INDArray paramView) |
INDArray |
WeightInitXavier.init(double fanIn,
double fanOut,
long[] shape,
char order,
INDArray paramView) |
INDArray |
WeightInitVarScalingUniformFanOut.init(double fanIn,
double fanOut,
long[] shape,
char order,
INDArray paramView) |
INDArray |
WeightInitVarScalingUniformFanIn.init(double fanIn,
double fanOut,
long[] shape,
char order,
INDArray paramView) |
INDArray |
WeightInitVarScalingUniformFanAvg.init(double fanIn,
double fanOut,
long[] shape,
char order,
INDArray paramView) |
INDArray |
WeightInitVarScalingNormalFanOut.init(double fanIn,
double fanOut,
long[] shape,
char order,
INDArray paramView) |
INDArray |
WeightInitVarScalingNormalFanIn.init(double fanIn,
double fanOut,
long[] shape,
char order,
INDArray paramView) |
INDArray |
WeightInitVarScalingNormalFanAvg.init(double fanIn,
double fanOut,
long[] shape,
char order,
INDArray paramView) |
INDArray |
WeightInitUniform.init(double fanIn,
double fanOut,
long[] shape,
char order,
INDArray paramView) |
INDArray |
WeightInitSigmoidUniform.init(double fanIn,
double fanOut,
long[] shape,
char order,
INDArray paramView) |
INDArray |
WeightInitReluUniform.init(double fanIn,
double fanOut,
long[] shape,
char order,
INDArray paramView) |
INDArray |
WeightInitRelu.init(double fanIn,
double fanOut,
long[] shape,
char order,
INDArray paramView) |
INDArray |
WeightInitNormal.init(double fanIn,
double fanOut,
long[] shape,
char order,
INDArray paramView) |
INDArray |
WeightInitLecunUniform.init(double fanIn,
double fanOut,
long[] shape,
char order,
INDArray paramView) |
INDArray |
WeightInitIdentity.init(double fanIn,
double fanOut,
long[] shape,
char order,
INDArray paramView) |
INDArray |
WeightInitDistribution.init(double fanIn,
double fanOut,
long[] shape,
char order,
INDArray paramView) |
INDArray |
WeightInitConstant.init(double fanIn,
double fanOut,
long[] shape,
char order,
INDArray paramView) |
INDArray |
IWeightInit.init(double fanIn,
double fanOut,
long[] shape,
char order,
INDArray paramView)
Initialize parameters in the given view.
|
static INDArray |
WeightInitUtil.initWeights(double fanIn,
double fanOut,
int[] shape,
WeightInit initScheme,
Distribution dist,
char order,
INDArray paramView)
Deprecated.
|
static INDArray |
WeightInitUtil.initWeights(double fanIn,
double fanOut,
int[] shape,
WeightInit initScheme,
Distribution dist,
INDArray paramView)
Deprecated.
|
static INDArray |
WeightInitUtil.initWeights(double fanIn,
double fanOut,
long[] shape,
WeightInit initScheme,
Distribution dist,
char order,
INDArray paramView) |
static INDArray |
WeightInitUtil.initWeights(double fanIn,
double fanOut,
long[] shape,
WeightInit initScheme,
Distribution dist,
INDArray paramView)
Initializes a matrix with the given weight initialization scheme.
|
static INDArray |
WeightInitUtil.reshapeWeights(int[] shape,
INDArray paramsView)
Reshape the parameters view, without modifying the paramsView array values.
|
static INDArray |
WeightInitUtil.reshapeWeights(int[] shape,
INDArray paramsView,
char flatteningOrder)
Reshape the parameters view, without modifying the paramsView array values.
|
static INDArray |
WeightInitUtil.reshapeWeights(long[] shape,
INDArray paramsView)
Reshape the parameters view, without modifying the paramsView array values.
|
static INDArray |
WeightInitUtil.reshapeWeights(long[] shape,
INDArray paramsView,
char flatteningOrder)
Reshape the parameters view, without modifying the paramsView array values.
|
| Modifier and Type | Method and Description |
|---|---|
INDArray |
WeightInitEmbedding.init(double fanIn,
double fanOut,
long[] shape,
char order,
INDArray paramView) |
| Modifier and Type | Method and Description |
|---|---|
INDArray |
WeightInitEmbedding.init(double fanIn,
double fanOut,
long[] shape,
char order,
INDArray paramView) |
void |
EmbeddingInitializer.loadWeightsInto(INDArray array)
Load the weights into the specified INDArray
|
void |
ArrayEmbeddingInitializer.loadWeightsInto(INDArray array) |
| Constructor and Description |
|---|
ArrayEmbeddingInitializer(INDArray embeddings) |
| Modifier and Type | Method and Description |
|---|---|
INDArray |
LayerWorkspaceMgr.leverageTo(ArrayType arrayType,
INDArray array) |
INDArray |
LayerWorkspaceMgr.validateArrayLocation(ArrayType arrayType,
INDArray array,
boolean migrateIfInvalid,
boolean exceptionIfDetached) |
| Modifier and Type | Method and Description |
|---|---|
INDArray |
LayerWorkspaceMgr.leverageTo(ArrayType arrayType,
INDArray array) |
INDArray |
LayerWorkspaceMgr.validateArrayLocation(ArrayType arrayType,
INDArray array,
boolean migrateIfInvalid,
boolean exceptionIfDetached) |
| Modifier and Type | Method and Description |
|---|---|
double |
LineOptimizer.optimize(INDArray parameters,
INDArray gradient,
INDArray searchDirection,
LayerWorkspaceMgr workspaceMgr)
Line optimizer
|
void |
ConvexOptimizer.postStep(INDArray line)
After the step has been made, do an action
|
void |
StepFunction.step(INDArray x,
INDArray line)
Step with no parameters
|
void |
StepFunction.step(INDArray x,
INDArray line,
double step)
Step with the given parameters
|
| Modifier and Type | Method and Description |
|---|---|
void |
TrainingListener.onForwardPass(Model model,
List<INDArray> activations)
Called once per iteration (forward pass) for activations (usually for a
MultiLayerNetwork),
only at training time |
void |
BaseTrainingListener.onForwardPass(Model model,
List<INDArray> activations) |
void |
TrainingListener.onForwardPass(Model model,
Map<String,INDArray> activations)
Called once per iteration (forward pass) for activations (usually for a
ComputationGraph),
only at training time |
void |
BaseTrainingListener.onForwardPass(Model model,
Map<String,INDArray> activations) |
| Modifier and Type | Field and Description |
|---|---|
protected INDArray |
SharedGradient.gradient |
| Modifier and Type | Method and Description |
|---|---|
protected void |
EvaluativeListener.evalAtIndex(IEvaluation evaluation,
INDArray[] labels,
INDArray[] predictions,
int index) |
protected void |
EvaluativeListener.evalAtIndex(IEvaluation evaluation,
INDArray[] labels,
INDArray[] predictions,
int index) |
| Modifier and Type | Method and Description |
|---|---|
void |
SleepyTrainingListener.onForwardPass(Model model,
List<INDArray> activations) |
void |
FailureTestingListener.onForwardPass(Model model,
List<INDArray> activations) |
void |
SleepyTrainingListener.onForwardPass(Model model,
Map<String,INDArray> activations) |
void |
FailureTestingListener.onForwardPass(Model model,
Map<String,INDArray> activations) |
| Modifier and Type | Method and Description |
|---|---|
double |
BackTrackLineSearch.optimize(INDArray parameters,
INDArray gradients,
INDArray searchDirection,
LayerWorkspaceMgr workspaceMgr) |
protected void |
BaseOptimizer.postFirstStep(INDArray gradient) |
void |
StochasticGradientDescent.postStep(INDArray gradient) |
void |
LineGradientDescent.postStep(INDArray gradient) |
void |
LBFGS.postStep(INDArray gradient) |
void |
ConjugateGradient.postStep(INDArray gradient) |
void |
BaseOptimizer.postStep(INDArray gradient)
Post step to update searchDirection with new gradient and parameter information
|
double |
BackTrackLineSearch.setScoreFor(INDArray parameters,
LayerWorkspaceMgr workspaceMgr) |
| Modifier and Type | Field and Description |
|---|---|
protected INDArray |
BasicGradientsAccumulator.storage |
protected INDArray |
BasicGradientsAccumulator.updates |
| Modifier and Type | Field and Description |
|---|---|
protected ThreadLocal<INDArray> |
EncodedGradientsAccumulator.accumulator |
protected List<INDArray> |
BasicGradientsAccumulator.candidates |
protected List<BlockingQueue<INDArray>> |
EncodedGradientsAccumulator.messages |
protected Map<Long,INDArray> |
IndexedTail.updates |
| Modifier and Type | Method and Description |
|---|---|
INDArray |
EncodingHandler.decodeUpdates(INDArray message)
Deprecated.
|
INDArray |
EncodingHandler.encodeUpdates(int iteration,
int epoch,
INDArray updates) |
INDArray |
SmartFancyBlockingQueue.poll() |
protected INDArray |
SmartFancyBlockingQueue.smartDecompress(INDArray encoded,
INDArray target) |
protected INDArray |
IndexedTail.smartDecompress(INDArray encoded,
INDArray target) |
| Modifier and Type | Method and Description |
|---|---|
void |
EncodingHandler.applyPostProcessor(int iteration,
int epoch,
Double lastThreshold,
INDArray residuals) |
void |
GradientsAccumulator.applyUpdate(StepFunction function,
INDArray params,
INDArray updates,
boolean isFinalStep)
This method applies accumulated updates via given StepFunction
|
void |
EncodedGradientsAccumulator.applyUpdate(StepFunction function,
INDArray params,
INDArray updates,
boolean isFinalStep)
This method applies accumulated updates via given StepFunction
|
void |
BasicGradientsAccumulator.applyUpdate(StepFunction function,
INDArray params,
INDArray grad,
boolean isFinalStep)
This method applies accumulated updates via given StepFunction
|
void |
GradientsAccumulator.applyUpdate(StepFunction function,
INDArray params,
INDArray updates,
double alpha)
This method applies accumulated updates via given StepFunction
|
void |
EncodedGradientsAccumulator.applyUpdate(StepFunction function,
INDArray params,
INDArray updates,
double alpha)
This method applies accumulated updates via given StepFunction
|
void |
BasicGradientsAccumulator.applyUpdate(StepFunction function,
INDArray params,
INDArray grad,
double alpha)
This method applies accumulated updates via given StepFunction
|
boolean |
MessageHandler.broadcastUpdates(INDArray updates,
int iterationNumber,
int epochNumber)
This method does broadcast of given update message across network
|
boolean |
LocalHandler.broadcastUpdates(INDArray updates,
int iterationNumber,
int epochNumber) |
boolean |
EncodingHandler.broadcastUpdates(INDArray updates,
int iterationNumber,
int epochNumber) |
INDArray |
EncodingHandler.decodeUpdates(INDArray message)
Deprecated.
|
boolean |
IndexedTail.drainTo(INDArray array) |
boolean |
IndexedTail.drainTo(long threadId,
INDArray array) |
INDArray |
EncodingHandler.encodeUpdates(int iteration,
int epoch,
INDArray updates) |
void |
SmartFancyBlockingQueue.put(INDArray array) |
void |
IndexedTail.put(INDArray update)
This mehtod adds update, with optional collapse
|
void |
GradientsAccumulator.receiveUpdate(INDArray array)
This method accepts updates suitable for StepFunction and puts them to the queue, which is used in backpropagation loop
PLEASE NOTE: array is expected to be ready for use and match params dimensionality
|
void |
EncodedGradientsAccumulator.receiveUpdate(INDArray array)
This method accepts updates suitable for StepFunction and puts them to the queue, which is used in backpropagation loop
PLEASE NOTE: array is expected to be ready for use and match params dimensionality
|
void |
BasicGradientsAccumulator.receiveUpdate(INDArray array)
This method accepts updates suitable for StepFunction and puts them to the queue, which is used in backpropagation loop
PLEASE NOTE: array is expected to be ready for use and match params dimensionality
|
protected void |
EncodingHandler.residualDebugOutputIfRequired(INDArray residual) |
protected void |
EncodingHandler.sendMessage(INDArray message,
int iterationNumber,
int epochNumber)
This method does loops encoded data back to updates queue
|
protected INDArray |
SmartFancyBlockingQueue.smartDecompress(INDArray encoded,
INDArray target) |
protected INDArray |
IndexedTail.smartDecompress(INDArray encoded,
INDArray target) |
void |
GradientsAccumulator.storeUpdate(INDArray array,
int iterationNumber,
int epochNumber)
This method accepts updates suitable for StepFunction, and accumulates/propagates it across all workers
|
void |
EncodedGradientsAccumulator.storeUpdate(INDArray array,
int iterationNumber,
int epochNumber)
This method accepts updates suitable for StepFunction, and accumulates/propagates it across all workers
|
void |
BasicGradientsAccumulator.storeUpdate(INDArray array,
int iterationNumber,
int epochNumber)
This method accepts updates suitable for StepFunction, and accumulates/propagates it across all workers
|
| Constructor and Description |
|---|
SmartFancyBlockingQueue(int decompressionThreshold,
BlockingQueue<INDArray> queue,
INDArray paramsMatrix) |
SmartFancyBlockingQueue(int decompressionThreshold,
INDArray paramsMatrix) |
| Constructor and Description |
|---|
SmartFancyBlockingQueue(int decompressionThreshold,
BlockingQueue<INDArray> queue,
INDArray paramsMatrix) |
| Modifier and Type | Method and Description |
|---|---|
double |
ThresholdAlgorithm.calculateThreshold(int iteration,
int epoch,
Double lastThreshold,
Boolean lastWasDense,
Double lastSparsityRatio,
INDArray updatesPlusResidual) |
void |
ResidualPostProcessor.processResidual(int iteration,
int epoch,
double lastThreshold,
INDArray residualVector) |
| Modifier and Type | Method and Description |
|---|---|
void |
ResidualClippingPostProcessor.processResidual(int iteration,
int epoch,
double lastThreshold,
INDArray residualVector) |
void |
NoOpResidualPostProcessor.processResidual(int iteration,
int epoch,
double lastThreshold,
INDArray residualVector) |
| Modifier and Type | Method and Description |
|---|---|
double |
TargetSparsityThresholdAlgorithm.calculateThreshold(int iteration,
int epoch,
Double lastThreshold,
Boolean lastWasDense,
Double lastSparsityRatio,
INDArray updatesPlusResidual) |
double |
FixedThresholdAlgorithm.calculateThreshold(int iteration,
int epoch,
Double lastThreshold,
Boolean lastWasDense,
Double lastSparsityRatio,
INDArray updatesPlusResidual) |
double |
AdaptiveThresholdAlgorithm.calculateThreshold(int iteration,
int epoch,
Double lastThreshold,
Boolean lastWasDense,
Double lastSparsityRatio,
INDArray updatesPlusResidual) |
| Modifier and Type | Method and Description |
|---|---|
void |
NegativeGradientStepFunction.step(INDArray x,
INDArray line) |
void |
NegativeDefaultStepFunction.step(INDArray x,
INDArray line) |
void |
GradientStepFunction.step(INDArray x,
INDArray line) |
void |
DefaultStepFunction.step(INDArray x,
INDArray line) |
void |
NegativeGradientStepFunction.step(INDArray x,
INDArray line,
double step) |
void |
NegativeDefaultStepFunction.step(INDArray parameters,
INDArray searchDirection,
double step) |
void |
GradientStepFunction.step(INDArray x,
INDArray line,
double step) |
void |
DefaultStepFunction.step(INDArray parameters,
INDArray searchDirection,
double step)
Does x = x + stepSize * line
|
| Modifier and Type | Field and Description |
|---|---|
protected Supplier<INDArray> |
ParallelWrapper.modelParamsSupplier |
protected Supplier<INDArray> |
ParallelWrapper.Builder.modelParamsSupplier |
protected Supplier<INDArray> |
ParallelWrapper.updaterParamsSupplier |
protected Supplier<INDArray> |
ParallelWrapper.Builder.updaterParamsSupplier |
| Modifier and Type | Method and Description |
|---|---|
INDArray |
ParallelInference.output(DataSet dataSet) |
INDArray |
ParallelInference.output(double[] input) |
INDArray |
ParallelInference.output(float[] input) |
INDArray[] |
ParallelInference.output(INDArray... input)
Generate predictions/output from the netwonk
|
INDArray |
ParallelInference.output(INDArray input) |
INDArray[] |
ParallelInference.output(INDArray[] input,
INDArray[] inputMasks)
Generate predictions/outputs from the network, optionally using input masks for predictions
|
INDArray[] |
InplaceParallelInference.output(INDArray[] input,
INDArray[] inputMasks) |
INDArray[] |
InplaceParallelInference.ModelSelector.output(INDArray[] input,
INDArray[] inputMasks) |
protected INDArray[] |
InplaceParallelInference.ModelHolder.output(INDArray[] input,
INDArray[] inputMasks) |
INDArray |
ParallelInference.output(INDArray input,
INDArray inputMask) |
| Modifier and Type | Method and Description |
|---|---|
INDArray[] |
ParallelInference.output(INDArray... input)
Generate predictions/output from the netwonk
|
INDArray |
ParallelInference.output(INDArray input) |
INDArray[] |
ParallelInference.output(INDArray[] input,
INDArray[] inputMasks)
Generate predictions/outputs from the network, optionally using input masks for predictions
|
INDArray[] |
ParallelInference.output(INDArray[] input,
INDArray[] inputMasks)
Generate predictions/outputs from the network, optionally using input masks for predictions
|
INDArray[] |
InplaceParallelInference.output(INDArray[] input,
INDArray[] inputMasks) |
INDArray[] |
InplaceParallelInference.output(INDArray[] input,
INDArray[] inputMasks) |
INDArray[] |
InplaceParallelInference.ModelSelector.output(INDArray[] input,
INDArray[] inputMasks) |
INDArray[] |
InplaceParallelInference.ModelSelector.output(INDArray[] input,
INDArray[] inputMasks) |
protected INDArray[] |
InplaceParallelInference.ModelHolder.output(INDArray[] input,
INDArray[] inputMasks) |
protected INDArray[] |
InplaceParallelInference.ModelHolder.output(INDArray[] input,
INDArray[] inputMasks) |
INDArray |
ParallelInference.output(INDArray input,
INDArray inputMask) |
<T> T |
ParallelInference.output(ModelAdapter<T> adapter,
INDArray... inputs)
This method does forward pass and returns output provided by OutputAdapter
|
<T> T |
ParallelInference.output(ModelAdapter<T> adapter,
INDArray[] input,
INDArray[] inputMasks)
This method does forward pass and returns output provided by OutputAdapter
|
<T> T |
ParallelInference.output(ModelAdapter<T> adapter,
INDArray[] input,
INDArray[] inputMasks)
This method does forward pass and returns output provided by OutputAdapter
|
<T> T |
InplaceParallelInference.output(ModelAdapter<T> adapter,
INDArray[] input,
INDArray[] inputMasks,
INDArray[] labelsMasks)
This method does forward pass and returns output provided by OutputAdapter
|
<T> T |
InplaceParallelInference.output(ModelAdapter<T> adapter,
INDArray[] input,
INDArray[] inputMasks,
INDArray[] labelsMasks)
This method does forward pass and returns output provided by OutputAdapter
|
<T> T |
InplaceParallelInference.output(ModelAdapter<T> adapter,
INDArray[] input,
INDArray[] inputMasks,
INDArray[] labelsMasks)
This method does forward pass and returns output provided by OutputAdapter
|
protected InferenceObservable |
ParallelInference.ObservablesProvider.setInput(Observer observer,
INDArray... input) |
protected InferenceObservable |
ParallelInference.ObservablesProvider.setInput(Observer observer,
INDArray input) |
protected InferenceObservable |
ParallelInference.ObservablesProvider.setInput(Observer observer,
INDArray[] input,
INDArray[] inputMask) |
protected InferenceObservable |
ParallelInference.ObservablesProvider.setInput(Observer observer,
INDArray[] input,
INDArray[] inputMask) |
| Modifier and Type | Method and Description |
|---|---|
ParallelWrapper.Builder |
ParallelWrapper.Builder.modelParamsSupplier(Supplier<INDArray> supplier)
This method attaches supplier that'll probably provide model params update
PLEASE NOTE: This method is mostly used in Spark environment as part of fault tolerance logic
|
ParallelWrapper.Builder |
ParallelWrapper.Builder.updaterParamsSupplier(Supplier<INDArray> supplier)
This method attaches supplier that'll probably provide updater params update
PLEASE NOTE: This method is mostly used in Spark environment as part of fault tolerance logic
|
| Modifier and Type | Method and Description |
|---|---|
INDArray[] |
InferenceObservable.getOutput() |
| Modifier and Type | Method and Description |
|---|---|
void |
InferenceObservable.addInput(INDArray... input) |
void |
InferenceObservable.addInput(INDArray[] input,
INDArray[] inputMasks) |
void |
InferenceObservable.addInput(INDArray[] input,
INDArray[] inputMasks) |
| Modifier and Type | Method and Description |
|---|---|
INDArray[] |
BatchedInferenceObservable.getOutput() |
INDArray[] |
BasicInferenceObservable.getOutput() |
| Modifier and Type | Method and Description |
|---|---|
void |
BasicInferenceObservable.addInput(INDArray... input) |
void |
BatchedInferenceObservable.addInput(INDArray[] input,
INDArray[] inputMasks) |
void |
BatchedInferenceObservable.addInput(INDArray[] input,
INDArray[] inputMasks) |
void |
BasicInferenceObservable.addInput(INDArray[] input,
INDArray[] inputMasks) |
void |
BasicInferenceObservable.addInput(INDArray[] input,
INDArray[] inputMasks) |
| Constructor and Description |
|---|
BasicInferenceObservable(INDArray... inputs) |
BasicInferenceObservable(INDArray[] inputs,
INDArray[] inputMasks) |
BasicInferenceObservable(INDArray[] inputs,
INDArray[] inputMasks) |
| Modifier and Type | Method and Description |
|---|---|
void |
Trainer.updateModelParams(INDArray params)
This method updates replicated model params
|
void |
DefaultTrainer.updateModelParams(INDArray params) |
void |
Trainer.updateUpdaterParams(INDArray params)
This method updates updater params of the replicated model
|
void |
DefaultTrainer.updateUpdaterParams(INDArray params) |
| Modifier and Type | Method and Description |
|---|---|
void |
SystemInfoPrintListener.onForwardPass(Model model,
List<INDArray> activations) |
void |
SystemInfoFilePrintListener.onForwardPass(Model model,
List<INDArray> activations) |
void |
SystemInfoPrintListener.onForwardPass(Model model,
Map<String,INDArray> activations) |
void |
SystemInfoFilePrintListener.onForwardPass(Model model,
Map<String,INDArray> activations) |
| Modifier and Type | Field and Description |
|---|---|
protected INDArray |
Tsne.Y |
protected INDArray |
BarnesHutTsne.Y |
| Modifier and Type | Method and Description |
|---|---|
INDArray |
Tsne.calculate(INDArray X,
int targetDimensions,
double perplexity) |
INDArray |
BarnesHutTsne.computeGaussianPerplexity(INDArray d,
double perplexity)
Convert data to probability
co-occurrences (aka calculating the kernel)
|
INDArray |
Tsne.diag(INDArray ds) |
INDArray |
BarnesHutTsne.getData()
Return the matrix reduce to the NDim.
|
INDArray |
BarnesHutTsne.getGradientsViewArray() |
INDArray |
BarnesHutTsne.getParam(String param) |
INDArray |
BarnesHutTsne.Initializer.initData() |
INDArray |
BarnesHutTsne.input() |
INDArray |
BarnesHutTsne.params() |
| Modifier and Type | Method and Description |
|---|---|
Pair<INDArray,Double> |
BarnesHutTsne.computeGaussianKernel(INDArray distances,
double beta,
int k)
Computes a gaussian kernel
given a vector of squared distance distances
|
protected Pair<Double,INDArray> |
BarnesHutTsne.gradient(INDArray p) |
Pair<Double,INDArray> |
Tsne.hBeta(INDArray d,
double beta)
Computes a gaussian kernel
given a vector of squared distance distances
|
Map<String,INDArray> |
BarnesHutTsne.paramTable() |
Map<String,INDArray> |
BarnesHutTsne.paramTable(boolean backprapParamsOnly) |
| Modifier and Type | Method and Description |
|---|---|
INDArray |
Tsne.calculate(INDArray X,
int targetDimensions,
double perplexity) |
Pair<INDArray,Double> |
BarnesHutTsne.computeGaussianKernel(INDArray distances,
double beta,
int k)
Computes a gaussian kernel
given a vector of squared distance distances
|
INDArray |
BarnesHutTsne.computeGaussianPerplexity(INDArray d,
double perplexity)
Convert data to probability
co-occurrences (aka calculating the kernel)
|
INDArray |
Tsne.diag(INDArray ds) |
void |
BarnesHutTsne.fit(INDArray data) |
void |
BarnesHutTsne.fit(INDArray data,
int nDims)
Deprecated.
|
void |
BarnesHutTsne.fit(INDArray data,
LayerWorkspaceMgr workspaceMgr) |
protected Pair<Double,INDArray> |
BarnesHutTsne.gradient(INDArray p) |
Pair<Double,INDArray> |
Tsne.hBeta(INDArray d,
double beta)
Computes a gaussian kernel
given a vector of squared distance distances
|
void |
Tsne.plot(INDArray matrix,
int nDims,
List<String> labels,
String path) |
void |
BarnesHutTsne.plot(INDArray matrix,
int nDims,
List<String> labels,
String path)
Deprecated.
use
BarnesHutTsne.fit(INDArray) and BarnesHutTsne.saveAsFile(List, String) instead. |
void |
BarnesHutTsne.setBackpropGradientsViewArray(INDArray gradients) |
void |
BarnesHutTsne.setData(INDArray data) |
void |
BarnesHutTsne.setParam(String key,
INDArray val) |
void |
BarnesHutTsne.setParams(INDArray params) |
void |
BarnesHutTsne.setParamsViewArray(INDArray params) |
BarnesHutTsne.Builder |
BarnesHutTsne.Builder.staticInit(INDArray staticInput) |
void |
BarnesHutTsne.step(INDArray p,
int i)
An individual iteration
|
org.deeplearning4j.plot.BarnesHutTsne.SymResult |
BarnesHutTsne.symmetrized(INDArray rowP,
INDArray colP,
INDArray valP)
Symmetrize the value matrix
|
void |
BarnesHutTsne.update(INDArray gradient,
String paramType) |
static void |
BarnesHutTsne.zeroMean(INDArray input) |
| Modifier and Type | Method and Description |
|---|---|
void |
BarnesHutTsne.setParamTable(Map<String,INDArray> paramTable) |
| Constructor and Description |
|---|
BarnesHutTsne(int numDimensions,
String simiarlityFunction,
double theta,
boolean invert,
int maxIter,
double realMin,
double initialMomentum,
double finalMomentum,
double momentum,
int switchMomentumIteration,
boolean normalize,
int stopLyingIteration,
double tolerance,
double learningRate,
boolean useAdaGrad,
double perplexity,
TrainingListener TrainingListener,
double minGain,
int vpTreeWorkers,
WorkspaceMode workspaceMode,
INDArray staticInput) |
Initializer(INDArray input) |
| Modifier and Type | Method and Description |
|---|---|
INDArray[] |
IHistoryProcessor.getHistory()
Returns compressed arrays, which must be rescaled based
on the value returned by
IHistoryProcessor.getScale(). |
INDArray[] |
HistoryProcessor.getHistory() |
static <O,A,AS extends ActionSpace<A>> |
Learning.getInput(MDP<O,A,AS> mdp,
O obs) |
| Modifier and Type | Method and Description |
|---|---|
void |
IHistoryProcessor.add(INDArray image) |
void |
HistoryProcessor.add(INDArray obs) |
static Integer |
Learning.getMaxAction(INDArray vector) |
void |
IHistoryProcessor.record(INDArray image) |
void |
HistoryProcessor.record(INDArray raw) |
| Modifier and Type | Method and Description |
|---|---|
protected INDArray |
AsyncThreadDiscrete.processHistory(INDArray input) |
| Modifier and Type | Method and Description |
|---|---|
protected INDArray |
AsyncThreadDiscrete.processHistory(INDArray input) |
| Modifier and Type | Method and Description |
|---|---|
static <A> INDArray |
Transition.buildStackedNextObservations(List<Transition<A>> transitions)
Stack along the 0-dimension all the next observations of the batch in a INDArray.
|
static <A> INDArray |
Transition.buildStackedObservations(List<Transition<A>> transitions)
Stack along the 0-dimension all the observations of the batch in a INDArray.
|
static INDArray |
Transition.concat(INDArray[] history)
concat an array history into a single INDArry of as many channel
as element in the history array
|
| Modifier and Type | Method and Description |
|---|---|
static INDArray |
Transition.concat(INDArray[] history)
concat an array history into a single INDArry of as many channel
as element in the history array
|
| Modifier and Type | Field and Description |
|---|---|
protected INDArray |
BaseDQNAlgorithm.qNetworkNextObservation
In litterature, this corresponds to Q{net}(s(t+1), a)
|
protected INDArray |
BaseDQNAlgorithm.targetQNetworkNextObservation
In litterature, this corresponds to Q{tnet}(s(t+1), a)
|
| Modifier and Type | Method and Description |
|---|---|
protected void |
StandardDQN.initComputation(INDArray observations,
INDArray nextObservations) |
protected void |
DoubleDQN.initComputation(INDArray observations,
INDArray nextObservations) |
protected void |
BaseTDTargetAlgorithm.initComputation(INDArray observations,
INDArray nextObservations)
Called just before the calculation starts
|
protected void |
BaseDQNAlgorithm.initComputation(INDArray observations,
INDArray nextObservations) |
| Modifier and Type | Method and Description |
|---|---|
INDArray[] |
NeuralNet.outputAll(INDArray batch) |
| Modifier and Type | Method and Description |
|---|---|
void |
NeuralNet.fit(INDArray input,
INDArray[] labels)
fit from input and labels
|
void |
NeuralNet.fit(INDArray input,
INDArray[] labels)
fit from input and labels
|
Gradient[] |
NeuralNet.gradient(INDArray input,
INDArray[] labels)
Calculate the gradients from input and label (target) of all outputs
|
Gradient[] |
NeuralNet.gradient(INDArray input,
INDArray[] labels)
Calculate the gradients from input and label (target) of all outputs
|
INDArray[] |
NeuralNet.outputAll(INDArray batch) |
| Modifier and Type | Method and Description |
|---|---|
INDArray |
ActorCriticLoss.computeGradient(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask) |
INDArray |
ActorCriticLoss.computeScoreArray(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask) |
INDArray[] |
IActorCritic.outputAll(INDArray batch) |
INDArray[] |
ActorCriticSeparate.outputAll(INDArray batch) |
INDArray[] |
ActorCriticCompGraph.outputAll(INDArray batch) |
| Modifier and Type | Method and Description |
|---|---|
Pair<Double,INDArray> |
ActorCriticLoss.computeGradientAndScore(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask,
boolean average) |
| Modifier and Type | Method and Description |
|---|---|
INDArray |
ActorCriticLoss.computeGradient(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask) |
Pair<Double,INDArray> |
ActorCriticLoss.computeGradientAndScore(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask,
boolean average) |
double |
ActorCriticLoss.computeScore(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask,
boolean average) |
INDArray |
ActorCriticLoss.computeScoreArray(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask) |
void |
IActorCritic.fit(INDArray input,
INDArray[] labels) |
void |
IActorCritic.fit(INDArray input,
INDArray[] labels) |
void |
ActorCriticSeparate.fit(INDArray input,
INDArray[] labels) |
void |
ActorCriticSeparate.fit(INDArray input,
INDArray[] labels) |
void |
ActorCriticCompGraph.fit(INDArray input,
INDArray[] labels) |
void |
ActorCriticCompGraph.fit(INDArray input,
INDArray[] labels) |
Gradient[] |
IActorCritic.gradient(INDArray input,
INDArray[] labels) |
Gradient[] |
IActorCritic.gradient(INDArray input,
INDArray[] labels) |
Gradient[] |
ActorCriticSeparate.gradient(INDArray input,
INDArray[] labels) |
Gradient[] |
ActorCriticSeparate.gradient(INDArray input,
INDArray[] labels) |
Gradient[] |
ActorCriticCompGraph.gradient(INDArray input,
INDArray[] labels) |
Gradient[] |
ActorCriticCompGraph.gradient(INDArray input,
INDArray[] labels) |
INDArray[] |
IActorCritic.outputAll(INDArray batch) |
INDArray[] |
ActorCriticSeparate.outputAll(INDArray batch) |
INDArray[] |
ActorCriticCompGraph.outputAll(INDArray batch) |
| Modifier and Type | Method and Description |
|---|---|
INDArray |
IDQN.output(INDArray batch) |
INDArray |
DQN.output(INDArray batch) |
INDArray |
IDQN.output(Observation observation) |
INDArray |
DQN.output(Observation observation) |
INDArray[] |
IDQN.outputAll(INDArray batch) |
INDArray[] |
DQN.outputAll(INDArray batch) |
| Modifier and Type | Method and Description |
|---|---|
void |
IDQN.fit(INDArray input,
INDArray labels) |
void |
DQN.fit(INDArray input,
INDArray labels) |
void |
IDQN.fit(INDArray input,
INDArray[] labels) |
void |
IDQN.fit(INDArray input,
INDArray[] labels) |
void |
DQN.fit(INDArray input,
INDArray[] labels) |
void |
DQN.fit(INDArray input,
INDArray[] labels) |
Gradient[] |
IDQN.gradient(INDArray input,
INDArray label) |
Gradient[] |
DQN.gradient(INDArray input,
INDArray labels) |
Gradient[] |
IDQN.gradient(INDArray input,
INDArray[] label) |
Gradient[] |
IDQN.gradient(INDArray input,
INDArray[] label) |
Gradient[] |
DQN.gradient(INDArray input,
INDArray[] labels) |
Gradient[] |
DQN.gradient(INDArray input,
INDArray[] labels) |
INDArray |
IDQN.output(INDArray batch) |
INDArray |
DQN.output(INDArray batch) |
INDArray[] |
IDQN.outputAll(INDArray batch) |
INDArray[] |
DQN.outputAll(INDArray batch) |
| Modifier and Type | Method and Description |
|---|---|
INDArray |
Observation.getData() |
| Constructor and Description |
|---|
Observation(INDArray data) |
Observation(INDArray[] data) |
| Modifier and Type | Method and Description |
|---|---|
INDArray |
PoolContentAssembler.assemble(INDArray[] poolContent) |
INDArray |
ChannelStackPoolContentAssembler.assemble(INDArray[] poolContent)
Will return a new INDArray with one more dimension and with poolContent stacked along dimension 0.
|
INDArray[] |
ObservationPool.get() |
INDArray[] |
CircularFifoObservationPool.get() |
| Modifier and Type | Method and Description |
|---|---|
void |
ObservationPool.add(INDArray observation) |
void |
CircularFifoObservationPool.add(INDArray elem)
Add an element to the pool, if this addition would make the pool to overflow, the added element replaces the oldest one.
|
INDArray |
PoolContentAssembler.assemble(INDArray[] poolContent) |
INDArray |
ChannelStackPoolContentAssembler.assemble(INDArray[] poolContent)
Will return a new INDArray with one more dimension and with poolContent stacked along dimension 0.
|
| Modifier and Type | Method and Description |
|---|---|
abstract A |
Policy.nextAction(INDArray input) |
A |
IPolicy.nextAction(INDArray input) |
A |
EpsGreedy.nextAction(INDArray input) |
Integer |
DQNPolicy.nextAction(INDArray input) |
Integer |
BoltzmannQ.nextAction(INDArray input) |
Integer |
ACPolicy.nextAction(INDArray input) |
| Modifier and Type | Method and Description |
|---|---|
INDArray |
ObservationSpace.getHigh() |
INDArray |
ObservationSpace.getLow() |
| Constructor and Description |
|---|
HighLowDiscrete(INDArray matrix) |
| Modifier and Type | Method and Description |
|---|---|
INDArray |
LegacyMDPWrapper.WrapperObservationSpace.getHigh() |
INDArray |
LegacyMDPWrapper.WrapperObservationSpace.getLow() |
| Constructor and Description |
|---|
NetBroadcastTuple(ComputationGraphConfiguration graphConfiguration,
INDArray parameters,
INDArray updaterState) |
NetBroadcastTuple(MultiLayerConfiguration configuration,
ComputationGraphConfiguration graphConfiguration,
INDArray parameters,
INDArray updaterState) |
NetBroadcastTuple(MultiLayerConfiguration configuration,
ComputationGraphConfiguration graphConfiguration,
INDArray parameters,
INDArray updaterState,
AtomicInteger counter) |
NetBroadcastTuple(MultiLayerConfiguration configuration,
INDArray parameters,
INDArray updaterState) |
| Modifier and Type | Method and Description |
|---|---|
INDArray |
Add.call(INDArray v1,
INDArray v2) |
| Modifier and Type | Method and Description |
|---|---|
INDArray |
Add.call(INDArray v1,
INDArray v2) |
| Modifier and Type | Field and Description |
|---|---|
protected org.apache.spark.broadcast.Broadcast<INDArray> |
BaseVaeScoreWithKeyFunction.params |
| Modifier and Type | Method and Description |
|---|---|
abstract INDArray |
BaseVaeScoreWithKeyFunction.computeScore(VariationalAutoencoder vae,
INDArray toScore) |
INDArray |
BaseVaeReconstructionProbWithKeyFunction.computeScore(VariationalAutoencoder vae,
INDArray toScore) |
| Modifier and Type | Method and Description |
|---|---|
abstract INDArray |
BaseVaeScoreWithKeyFunction.computeScore(VariationalAutoencoder vae,
INDArray toScore) |
INDArray |
BaseVaeReconstructionProbWithKeyFunction.computeScore(VariationalAutoencoder vae,
INDArray toScore) |
| Modifier and Type | Method and Description |
|---|---|
Iterator<scala.Tuple2<K,Double>> |
BaseVaeScoreWithKeyFunction.call(Iterator<scala.Tuple2<K,INDArray>> iterator) |
| Constructor and Description |
|---|
BaseVaeReconstructionProbWithKeyFunction(org.apache.spark.broadcast.Broadcast<INDArray> params,
org.apache.spark.broadcast.Broadcast<String> jsonConfig,
boolean useLogProbability,
int batchSize,
int numSamples) |
BaseVaeScoreWithKeyFunction(org.apache.spark.broadcast.Broadcast<INDArray> params,
org.apache.spark.broadcast.Broadcast<String> jsonConfig,
int batchSize) |
| Modifier and Type | Method and Description |
|---|---|
<K> org.apache.spark.api.java.JavaPairRDD<K,INDArray> |
SparkComputationGraph.feedForwardWithKeySingle(org.apache.spark.api.java.JavaPairRDD<K,INDArray> featuresData,
int batchSize)
Feed-forward the specified data, with the given keys. i.e., get the network output/predictions for the specified data
|
| Modifier and Type | Method and Description |
|---|---|
<K> org.apache.spark.api.java.JavaPairRDD<K,INDArray> |
SparkComputationGraph.feedForwardWithKeySingle(org.apache.spark.api.java.JavaPairRDD<K,INDArray> featuresData,
int batchSize)
Feed-forward the specified data, with the given keys. i.e., get the network output/predictions for the specified data
|
| Modifier and Type | Method and Description |
|---|---|
INDArray |
CGVaeReconstructionErrorWithKeyFunction.computeScore(VariationalAutoencoder vae,
INDArray toScore) |
| Modifier and Type | Method and Description |
|---|---|
scala.Tuple2<K,INDArray> |
ArrayPairToPair.call(scala.Tuple2<K,INDArray[]> v1) |
| Modifier and Type | Method and Description |
|---|---|
INDArray |
CGVaeReconstructionErrorWithKeyFunction.computeScore(VariationalAutoencoder vae,
INDArray toScore) |
| Modifier and Type | Method and Description |
|---|---|
scala.Tuple2<K,INDArray[]> |
PairToArrayPair.call(scala.Tuple2<K,INDArray> v1) |
| Constructor and Description |
|---|
CGVaeReconstructionErrorWithKeyFunction(org.apache.spark.broadcast.Broadcast<INDArray> params,
org.apache.spark.broadcast.Broadcast<String> jsonConfig,
int batchSize) |
CGVaeReconstructionProbWithKeyFunction(org.apache.spark.broadcast.Broadcast<INDArray> params,
org.apache.spark.broadcast.Broadcast<String> jsonConfig,
boolean useLogProbability,
int batchSize,
int numSamples) |
ScoreExamplesFunction(org.apache.spark.broadcast.Broadcast<INDArray> params,
org.apache.spark.broadcast.Broadcast<String> jsonConfig,
boolean addRegularizationTerms,
int batchSize) |
ScoreExamplesWithKeyFunction(org.apache.spark.broadcast.Broadcast<INDArray> params,
org.apache.spark.broadcast.Broadcast<String> jsonConfig,
boolean addRegularizationTerms,
int batchSize) |
ScoreFlatMapFunctionCGDataSet(String json,
org.apache.spark.broadcast.Broadcast<INDArray> params,
int minibatchSize) |
ScoreFlatMapFunctionCGMultiDataSet(String json,
org.apache.spark.broadcast.Broadcast<INDArray> params,
int minibatchSize) |
| Modifier and Type | Method and Description |
|---|---|
<K> org.apache.spark.api.java.JavaPairRDD<K,INDArray> |
SparkDl4jMultiLayer.feedForwardWithKey(org.apache.spark.api.java.JavaPairRDD<K,INDArray> featuresData,
int batchSize)
Feed-forward the specified data, with the given keys. i.e., get the network output/predictions for the specified data
|
<K> org.apache.spark.api.java.JavaPairRDD<K,INDArray> |
SparkDl4jMultiLayer.feedForwardWithMaskAndKey(org.apache.spark.api.java.JavaPairRDD<K,scala.Tuple2<INDArray,INDArray>> featuresDataAndMask,
int batchSize)
Feed-forward the specified data (and optionally mask array), with the given keys. i.e., get the network
output/predictions for the specified data
|
| Modifier and Type | Method and Description |
|---|---|
<K> org.apache.spark.api.java.JavaPairRDD<K,INDArray> |
SparkDl4jMultiLayer.feedForwardWithKey(org.apache.spark.api.java.JavaPairRDD<K,INDArray> featuresData,
int batchSize)
Feed-forward the specified data, with the given keys. i.e., get the network output/predictions for the specified data
|
<K> org.apache.spark.api.java.JavaPairRDD<K,INDArray> |
SparkDl4jMultiLayer.feedForwardWithMaskAndKey(org.apache.spark.api.java.JavaPairRDD<K,scala.Tuple2<INDArray,INDArray>> featuresDataAndMask,
int batchSize)
Feed-forward the specified data (and optionally mask array), with the given keys. i.e., get the network
output/predictions for the specified data
|
<K> org.apache.spark.api.java.JavaPairRDD<K,INDArray> |
SparkDl4jMultiLayer.feedForwardWithMaskAndKey(org.apache.spark.api.java.JavaPairRDD<K,scala.Tuple2<INDArray,INDArray>> featuresDataAndMask,
int batchSize)
Feed-forward the specified data (and optionally mask array), with the given keys. i.e., get the network
output/predictions for the specified data
|
| Modifier and Type | Method and Description |
|---|---|
INDArray |
VaeReconstructionErrorWithKeyFunction.computeScore(VariationalAutoencoder vae,
INDArray toScore) |
| Modifier and Type | Method and Description |
|---|---|
Iterator<scala.Tuple2<K,INDArray>> |
FeedForwardWithKeyFunction.call(Iterator<scala.Tuple2<K,scala.Tuple2<INDArray,INDArray>>> iterator) |
scala.Tuple2<T,scala.Tuple2<INDArray,INDArray>> |
SingleToPairFunction.call(scala.Tuple2<T,INDArray> t2) |
scala.Tuple2<T,scala.Tuple2<INDArray,INDArray>> |
SingleToPairFunction.call(scala.Tuple2<T,INDArray> t2) |
| Modifier and Type | Method and Description |
|---|---|
INDArray |
VaeReconstructionErrorWithKeyFunction.computeScore(VariationalAutoencoder vae,
INDArray toScore) |
| Modifier and Type | Method and Description |
|---|---|
Iterator<scala.Tuple2<K,INDArray>> |
FeedForwardWithKeyFunction.call(Iterator<scala.Tuple2<K,scala.Tuple2<INDArray,INDArray>>> iterator) |
Iterator<scala.Tuple2<K,INDArray>> |
FeedForwardWithKeyFunction.call(Iterator<scala.Tuple2<K,scala.Tuple2<INDArray,INDArray>>> iterator) |
scala.Tuple2<T,scala.Tuple2<INDArray,INDArray>> |
SingleToPairFunction.call(scala.Tuple2<T,INDArray> t2) |
| Constructor and Description |
|---|
FeedForwardWithKeyFunction(org.apache.spark.broadcast.Broadcast<INDArray> params,
org.apache.spark.broadcast.Broadcast<String> jsonConfig,
int batchSize) |
ScoreExamplesFunction(org.apache.spark.broadcast.Broadcast<INDArray> params,
org.apache.spark.broadcast.Broadcast<String> jsonConfig,
boolean addRegularizationTerms,
int batchSize) |
ScoreExamplesWithKeyFunction(org.apache.spark.broadcast.Broadcast<INDArray> params,
org.apache.spark.broadcast.Broadcast<String> jsonConfig,
boolean addRegularizationTerms,
int batchSize) |
VaeReconstructionErrorWithKeyFunction(org.apache.spark.broadcast.Broadcast<INDArray> params,
org.apache.spark.broadcast.Broadcast<String> jsonConfig,
int batchSize) |
VaeReconstructionProbWithKeyFunction(org.apache.spark.broadcast.Broadcast<INDArray> params,
org.apache.spark.broadcast.Broadcast<String> jsonConfig,
boolean useLogProbability,
int batchSize,
int numSamples) |
| Constructor and Description |
|---|
ParameterAveragingTrainingResult(INDArray parameters,
INDArray updaterState,
double score,
Collection<StorageMetaData> listenerMetaData,
Collection<Persistable> listenerStaticInfo,
Collection<Persistable> listenerUpdates) |
ParameterAveragingTrainingResult(INDArray parameters,
INDArray updaterState,
double score,
SparkTrainingStats sparkTrainingStats,
Collection<StorageMetaData> listenerMetaData,
Collection<Persistable> listenerStaticInfo,
Collection<Persistable> listenerUpdates) |
| Modifier and Type | Method and Description |
|---|---|
INDArray |
GloveChange.getW1History() |
INDArray |
GloveChange.getW1Update() |
INDArray |
GloveChange.getW2History() |
INDArray |
GloveChange.getW2Update() |
| Modifier and Type | Method and Description |
|---|---|
void |
GloveChange.setW1History(INDArray w1History) |
void |
GloveChange.setW1Update(INDArray w1Update) |
void |
GloveChange.setW2History(INDArray w2History) |
void |
GloveChange.setW2Update(INDArray w2Update) |
| Constructor and Description |
|---|
GloveChange(VocabWord w1,
VocabWord w2,
INDArray w1Update,
INDArray w2Update,
double w1BiasUpdate,
double w2BiasUpdate,
double error,
INDArray w1History,
INDArray w2History,
double w1BiasHistory,
double w2BiasHistory) |
| Modifier and Type | Method and Description |
|---|---|
INDArray |
VocabHolder.getSyn0Vector(Integer wordIndex,
VocabCache<VocabWord> vocabCache) |
INDArray |
VocabHolder.getSyn1Vector(Integer point) |
INDArray |
Word2VecPerformerVoid.getTable()
Deprecated.
|
INDArray |
Word2VecParam.getTable()
Deprecated.
|
| Modifier and Type | Method and Description |
|---|---|
Iterator<Map.Entry<VocabWord,INDArray>> |
SecondIterationFunction.call(Iterator<scala.Tuple2<List<VocabWord>,Long>> pairIter) |
Iterator<Map.Entry<VocabWord,INDArray>> |
FirstIterationFunction.call(Iterator<scala.Tuple2<List<VocabWord>,Long>> pairIter) |
Pair<VocabWord,INDArray> |
MapToPairFunction.call(Map.Entry<VocabWord,INDArray> pair) |
Iterable<Map.Entry<VocabWord,INDArray>> |
VocabHolder.getSplit(VocabCache<VocabWord> vocabCache) |
| Modifier and Type | Method and Description |
|---|---|
void |
Word2VecPerformerVoid.setTable(INDArray table)
Deprecated.
|
void |
Word2VecParam.setTable(INDArray table)
Deprecated.
|
Word2VecParam.Builder |
Word2VecParam.Builder.table(INDArray table) |
| Modifier and Type | Method and Description |
|---|---|
Pair<VocabWord,INDArray> |
MapToPairFunction.call(Map.Entry<VocabWord,INDArray> pair) |
| Constructor and Description |
|---|
Word2Vec(INDArray trainedSyn1) |
Word2VecParam(boolean useAdaGrad,
double negative,
int numWords,
INDArray table,
int window,
AtomicLong nextRandom,
double alpha,
double minAlpha,
int totalWords,
int lastChecked,
org.apache.spark.broadcast.Broadcast<AtomicLong> wordCount,
InMemoryLookupTable weights,
int vectorLength,
org.apache.spark.broadcast.Broadcast<double[]> expTable)
Deprecated.
|
| Modifier and Type | Method and Description |
|---|---|
protected void |
SparkCBOW.iterateSample(ShallowSequenceElement currentWord,
int[] windowWords,
AtomicLong nextRandom,
double alpha,
boolean isInference,
int numLabels,
boolean trainWords,
INDArray inferenceVector) |
| Modifier and Type | Method and Description |
|---|---|
INDArray |
BaseSparkSequenceLearningAlgorithm.inferSequence(Sequence<ShallowSequenceElement> sequence,
long nextRandom,
double learningRate,
double minLearningRate,
int iterations) |
| Modifier and Type | Field and Description |
|---|---|
protected INDArray |
SilentTrainingDriver.params
Deprecated.
|
protected INDArray |
SilentTrainingDriver.updates
Deprecated.
|
| Modifier and Type | Method and Description |
|---|---|
protected void |
WiredEncodingHandler.sendMessage(INDArray message,
int iterationNumber,
int epochNumber)
Deprecated.
This method sends given message to all registered recipients
|
| Constructor and Description |
|---|
SilentTrainingDriver(INDArray params,
StepFunction stepFunction)
Deprecated.
|
| Modifier and Type | Field and Description |
|---|---|
protected INDArray |
SilentUpdatesMessage.updates |
| Constructor and Description |
|---|
SilentUpdatesMessage(INDArray encodedUpdates,
long updateId) |
| Modifier and Type | Field and Description |
|---|---|
protected INDArray |
UpdatesConsumer.params |
protected INDArray |
UpdatesConsumer.updates |
| Modifier and Type | Field and Description |
|---|---|
protected Atomic<INDArray> |
UpdaterParamsConsumer.params |
protected Atomic<INDArray> |
ModelParamsConsumer.params |
| Modifier and Type | Method and Description |
|---|---|
INDArray |
UpdaterParamsConsumer.get() |
INDArray |
ModelParamsConsumer.get() |
INDArray |
UpdatesConsumer.getParametersArray() |
| Modifier and Type | Method and Description |
|---|---|
void |
UpdatesConsumer.onNext(INDArray array) |
void |
UpdaterParamsConsumer.onNext(INDArray array) |
void |
ModelParamsConsumer.onNext(INDArray array) |
protected void |
WiredEncodingHandler.sendMessage(INDArray message,
int iterationNumber,
int epochNumber)
This method sends given message to all registered recipients
|
| Modifier and Type | Method and Description |
|---|---|
INDArray |
ArrayDescriptor.getArray() |
| Modifier and Type | Method and Description |
|---|---|
static org.apache.spark.api.java.JavaRDD<INDArray> |
Utils.getArrayRDD(org.apache.spark.api.java.JavaRDD<ArrayDescriptor> arrayDescriptorRDD) |
| Modifier and Type | Method and Description |
|---|---|
static org.apache.spark.api.java.JavaRDD<ArrayDescriptor> |
Utils.getArrayDescriptorRDD(org.apache.spark.api.java.JavaRDD<INDArray> indarrayRDD) |
| Constructor and Description |
|---|
ArrayDescriptor(INDArray array) |
| Modifier and Type | Method and Description |
|---|---|
static INDArray |
MLLibUtil.toMatrix(org.apache.spark.mllib.linalg.Matrix arr)
Convert an ndarray to a matrix.
|
static INDArray |
MLLibUtil.toVector(org.apache.spark.mllib.linalg.Vector arr)
Convert an ndarray to a vector
|
| Modifier and Type | Method and Description |
|---|---|
static org.apache.spark.broadcast.Broadcast<byte[]> |
SparkUtils.asByteArrayBroadcast(org.apache.spark.api.java.JavaSparkContext sc,
INDArray array) |
static org.apache.spark.mllib.linalg.Matrix |
MLLibUtil.toMatrix(INDArray arr)
Convert an ndarray to a matrix.
|
static org.apache.spark.mllib.linalg.Vector |
MLLibUtil.toVector(INDArray arr)
Convert an ndarray to a vector
|
| Modifier and Type | Method and Description |
|---|---|
protected static boolean |
ValidateDataSetFn.validateArrayShape(int[] featuresShape,
INDArray array) |
| Modifier and Type | Method and Description |
|---|---|
static INDArray |
WindowConverter.asExampleArray(Window window,
Word2Vec vec,
boolean normalize)
Converts a window (each word in the window)
in to a vector.
|
static INDArray |
WindowConverter.asExampleMatrix(Window window,
Word2Vec vec)
Converts a window (each word in the window)
in to a vector.
|
INDArray |
WordConverter.toInputMatrix() |
static INDArray |
WordConverter.toInputMatrix(List<Window> windows,
Word2Vec vec) |
INDArray |
WordConverter.toLabelMatrix(List<String> labels) |
static INDArray |
WordConverter.toLabelMatrix(List<String> labels,
List<Window> windows) |
| Modifier and Type | Method and Description |
|---|---|
void |
BaseStatsListener.onForwardPass(Model model,
List<INDArray> activations) |
void |
BaseStatsListener.onForwardPass(Model model,
Map<String,INDArray> activations) |
| Modifier and Type | Method and Description |
|---|---|
void |
ConvolutionalIterationListener.onForwardPass(Model model,
List<INDArray> activations) |
void |
ConvolutionalIterationListener.onForwardPass(Model model,
Map<String,INDArray> activations) |
| Constructor and Description |
|---|
Builder(INDArray array)
Build Histogram Builder instance for specified array
|
HistogramBin(INDArray array)
Builds histogram bin for specified array
|
| Modifier and Type | Method and Description |
|---|---|
static INDArray |
ConvolutionUtils.adapt2dMask(INDArray mask,
INDArray output,
LayerWorkspaceMgr workspaceMgr,
ArrayType type) |
static INDArray |
ConvolutionUtils.cnn1dMaskReduction(INDArray in,
int kernel,
int stride,
int padding,
int dilation,
ConvolutionMode cm)
Given a mask array for a 1D CNN layer of shape [minibatch, sequenceLength], reduce the mask according to the 1D CNN layer configuration.
|
static INDArray |
ConvolutionUtils.cnn2dMaskReduction(INDArray inMask,
int[] kernel,
int[] stride,
int[] padding,
int[] dilation,
ConvolutionMode convolutionMode)
Reduce a 2d CNN layer mask array (of 0s and 1s) according to the layer configuration.
|
static INDArray |
MaskedReductionUtil.maskedPoolingConvolution(PoolingType poolingType,
INDArray toReduce,
INDArray mask,
int pnorm,
DataType dataType) |
static INDArray |
MaskedReductionUtil.maskedPoolingEpsilonCnn(PoolingType poolingType,
INDArray input,
INDArray mask,
INDArray epsilon2d,
int pnorm,
DataType dataType) |
static INDArray |
MaskedReductionUtil.maskedPoolingEpsilonTimeSeries(PoolingType poolingType,
INDArray input,
INDArray mask,
INDArray epsilon2d,
int pnorm) |
static INDArray |
MaskedReductionUtil.maskedPoolingTimeSeries(PoolingType poolingType,
INDArray toReduce,
INDArray mask,
int pnorm,
DataType dataType) |
static INDArray |
TimeSeriesUtils.movingAverage(INDArray toAvg,
int n)
Calculate a moving average given the length
|
static INDArray |
NetworkUtils.output(Model model,
INDArray input)
Currently supports
MultiLayerNetwork and ComputationGraph models. |
protected static INDArray |
NetworkUtils.rebuildUpdaterStateArray(INDArray origUpdaterState,
List<UpdaterBlock> orig,
List<UpdaterBlock> newUpdater)
Rebuild the updater state after a learning rate change.
|
static INDArray |
TimeSeriesUtils.reshape2dTo3d(INDArray in,
int miniBatchSize) |
static INDArray |
TimeSeriesUtils.reshape2dTo3d(INDArray in,
long miniBatchSize,
LayerWorkspaceMgr workspaceMgr,
ArrayType arrayType) |
static INDArray |
ConvolutionUtils.reshape2dTo4d(INDArray in2d,
long[] toShape,
LayerWorkspaceMgr workspaceMgr,
ArrayType type) |
static INDArray |
ConvolutionUtils.reshape2dTo5d(Convolution3D.DataFormat format,
INDArray in2d,
long n,
long d,
long h,
long w,
long ch,
LayerWorkspaceMgr workspaceMgr,
ArrayType type) |
static INDArray |
ConvolutionUtils.reshape3dMask(INDArray mask,
LayerWorkspaceMgr workspaceMgr,
ArrayType type) |
static INDArray |
TimeSeriesUtils.reshape3dTo2d(INDArray in) |
static INDArray |
TimeSeriesUtils.reshape3dTo2d(INDArray in,
LayerWorkspaceMgr workspaceMgr,
ArrayType arrayType) |
static INDArray |
ConvolutionUtils.reshape4dMask(INDArray mask,
LayerWorkspaceMgr workspaceMgr,
ArrayType arrayType) |
static INDArray |
ConvolutionUtils.reshape4dTo2d(INDArray in,
LayerWorkspaceMgr workspaceMgr,
ArrayType type) |
static INDArray |
ConvolutionUtils.reshape5dTo2d(Convolution3D.DataFormat format,
INDArray in,
LayerWorkspaceMgr workspaceMgr,
ArrayType type) |
static INDArray |
ConvolutionUtils.reshapeCnn3dMask(Convolution3D.DataFormat format,
INDArray mask,
INDArray label,
LayerWorkspaceMgr workspaceMgr,
ArrayType type) |
static INDArray |
TimeSeriesUtils.reshapeCnnMaskToTimeSeriesMask(INDArray timeSeriesMaskAsCnnMask,
int minibatchSize)
Reshape CNN-style 4d mask array of shape [seqLength*minibatch,1,1,1] to time series mask [mb,seqLength]
This should match the assumptions (f order, etc) in RnnOutputLayer
|
static INDArray |
ConvolutionUtils.reshapeMaskIfRequired(INDArray mask,
INDArray output,
LayerWorkspaceMgr workspaceMgr,
ArrayType type) |
static INDArray |
TimeSeriesUtils.reshapePerOutputTimeSeriesMaskTo2d(INDArray perOutputTimeSeriesMask) |
static INDArray |
TimeSeriesUtils.reshapePerOutputTimeSeriesMaskTo2d(INDArray perOutputTimeSeriesMask,
LayerWorkspaceMgr workspaceMgr,
ArrayType arrayType) |
static INDArray |
TimeSeriesUtils.reshapeTimeSeriesMaskToCnn4dMask(INDArray timeSeriesMask,
LayerWorkspaceMgr workspaceMgr,
ArrayType arrayType)
Reshape time series mask arrays.
|
static INDArray |
TimeSeriesUtils.reshapeTimeSeriesMaskToVector(INDArray timeSeriesMask)
Reshape time series mask arrays.
|
static INDArray |
TimeSeriesUtils.reshapeTimeSeriesMaskToVector(INDArray timeSeriesMask,
LayerWorkspaceMgr workspaceMgr,
ArrayType arrayType)
Reshape time series mask arrays.
|
static INDArray |
TimeSeriesUtils.reshapeVectorToTimeSeriesMask(INDArray timeSeriesMaskAsVector,
int minibatchSize)
Reshape time series mask arrays.
|
static INDArray |
TimeSeriesUtils.reverseTimeSeries(INDArray in)
Reverse an input time series along the time dimension
|
static INDArray |
TimeSeriesUtils.reverseTimeSeries(INDArray in,
LayerWorkspaceMgr workspaceMgr,
ArrayType arrayType)
Reverse an input time series along the time dimension
|
static INDArray |
TimeSeriesUtils.reverseTimeSeriesMask(INDArray mask)
Reverse a (per time step) time series mask, with shape [minibatch, timeSeriesLength]
|
static INDArray |
TimeSeriesUtils.reverseTimeSeriesMask(INDArray mask,
LayerWorkspaceMgr workspaceMgr,
ArrayType arrayType)
Reverse a (per time step) time series mask, with shape [minibatch, timeSeriesLength]
|
| Modifier and Type | Method and Description |
|---|---|
static Pair<INDArray,int[]> |
TimeSeriesUtils.pullLastTimeSteps(INDArray pullFrom,
INDArray mask)
Extract out the last time steps (2d array from 3d array input) accounting for the mask layer, if present.
|
static Pair<INDArray,int[]> |
TimeSeriesUtils.pullLastTimeSteps(INDArray pullFrom,
INDArray mask,
LayerWorkspaceMgr workspaceMgr,
ArrayType arrayType)
Extract out the last time steps (2d array from 3d array input) accounting for the mask layer, if present.
|
List<INDArray> |
MovingWindowMatrix.windows()
Returns a list of non flattened moving window matrices
|
List<INDArray> |
MovingWindowMatrix.windows(boolean flattened)
Moving window, capture a row x column moving window of
a given matrix
|
| Modifier and Type | Method and Description |
|---|---|
static INDArray |
ConvolutionUtils.adapt2dMask(INDArray mask,
INDArray output,
LayerWorkspaceMgr workspaceMgr,
ArrayType type) |
static INDArray |
ConvolutionUtils.cnn1dMaskReduction(INDArray in,
int kernel,
int stride,
int padding,
int dilation,
ConvolutionMode cm)
Given a mask array for a 1D CNN layer of shape [minibatch, sequenceLength], reduce the mask according to the 1D CNN layer configuration.
|
static INDArray |
ConvolutionUtils.cnn2dMaskReduction(INDArray inMask,
int[] kernel,
int[] stride,
int[] padding,
int[] dilation,
ConvolutionMode convolutionMode)
Reduce a 2d CNN layer mask array (of 0s and 1s) according to the layer configuration.
|
static int[] |
Convolution3DUtils.get3DOutputSize(INDArray inputData,
int[] kernel,
int[] strides,
int[] padding,
ConvolutionMode convolutionMode,
int[] dilation,
boolean isNCDHW)
Get the output size (depth/height/width) for the given input data and CNN3D configuration
|
static int[] |
ConvolutionUtils.getDeconvolutionOutputSize(INDArray inputData,
int[] kernel,
int[] strides,
int[] padding,
ConvolutionMode convolutionMode,
int[] dilation)
Get the output size of a deconvolution operation for given input data.
|
static int[] |
ConvolutionUtils.getOutputSize(INDArray inputData,
int[] kernel,
int[] strides,
int[] padding,
ConvolutionMode convolutionMode) |
static int[] |
ConvolutionUtils.getOutputSize(INDArray inputData,
int[] kernel,
int[] strides,
int[] padding,
ConvolutionMode convolutionMode,
int[] dilation)
Get the output size (height/width) for the given input data and CNN configuration
|
static int |
Convolution1DUtils.getOutputSize(INDArray inputData,
int kernel,
int strides,
int padding,
ConvolutionMode convolutionMode) |
static int |
Convolution1DUtils.getOutputSize(INDArray inputData,
int kernel,
int strides,
int padding,
ConvolutionMode convolutionMode,
int dilation)
Get the output size (height) for the given input data and CNN1D configuration
|
static INDArray |
MaskedReductionUtil.maskedPoolingConvolution(PoolingType poolingType,
INDArray toReduce,
INDArray mask,
int pnorm,
DataType dataType) |
static INDArray |
MaskedReductionUtil.maskedPoolingEpsilonCnn(PoolingType poolingType,
INDArray input,
INDArray mask,
INDArray epsilon2d,
int pnorm,
DataType dataType) |
static INDArray |
MaskedReductionUtil.maskedPoolingEpsilonTimeSeries(PoolingType poolingType,
INDArray input,
INDArray mask,
INDArray epsilon2d,
int pnorm) |
static INDArray |
MaskedReductionUtil.maskedPoolingTimeSeries(PoolingType poolingType,
INDArray toReduce,
INDArray mask,
int pnorm,
DataType dataType) |
static INDArray |
TimeSeriesUtils.movingAverage(INDArray toAvg,
int n)
Calculate a moving average given the length
|
static INDArray |
NetworkUtils.output(Model model,
INDArray input)
Currently supports
MultiLayerNetwork and ComputationGraph models. |
static Pair<INDArray,int[]> |
TimeSeriesUtils.pullLastTimeSteps(INDArray pullFrom,
INDArray mask)
Extract out the last time steps (2d array from 3d array input) accounting for the mask layer, if present.
|
static Pair<INDArray,int[]> |
TimeSeriesUtils.pullLastTimeSteps(INDArray pullFrom,
INDArray mask,
LayerWorkspaceMgr workspaceMgr,
ArrayType arrayType)
Extract out the last time steps (2d array from 3d array input) accounting for the mask layer, if present.
|
protected static INDArray |
NetworkUtils.rebuildUpdaterStateArray(INDArray origUpdaterState,
List<UpdaterBlock> orig,
List<UpdaterBlock> newUpdater)
Rebuild the updater state after a learning rate change.
|
static INDArray |
TimeSeriesUtils.reshape2dTo3d(INDArray in,
int miniBatchSize) |
static INDArray |
TimeSeriesUtils.reshape2dTo3d(INDArray in,
long miniBatchSize,
LayerWorkspaceMgr workspaceMgr,
ArrayType arrayType) |
static INDArray |
ConvolutionUtils.reshape2dTo4d(INDArray in2d,
long[] toShape,
LayerWorkspaceMgr workspaceMgr,
ArrayType type) |
static INDArray |
ConvolutionUtils.reshape2dTo5d(Convolution3D.DataFormat format,
INDArray in2d,
long n,
long d,
long h,
long w,
long ch,
LayerWorkspaceMgr workspaceMgr,
ArrayType type) |
static INDArray |
ConvolutionUtils.reshape3dMask(INDArray mask,
LayerWorkspaceMgr workspaceMgr,
ArrayType type) |
static INDArray |
TimeSeriesUtils.reshape3dTo2d(INDArray in) |
static INDArray |
TimeSeriesUtils.reshape3dTo2d(INDArray in,
LayerWorkspaceMgr workspaceMgr,
ArrayType arrayType) |
static INDArray |
ConvolutionUtils.reshape4dMask(INDArray mask,
LayerWorkspaceMgr workspaceMgr,
ArrayType arrayType) |
static INDArray |
ConvolutionUtils.reshape4dTo2d(INDArray in,
LayerWorkspaceMgr workspaceMgr,
ArrayType type) |
static INDArray |
ConvolutionUtils.reshape5dTo2d(Convolution3D.DataFormat format,
INDArray in,
LayerWorkspaceMgr workspaceMgr,
ArrayType type) |
static INDArray |
ConvolutionUtils.reshapeCnn3dMask(Convolution3D.DataFormat format,
INDArray mask,
INDArray label,
LayerWorkspaceMgr workspaceMgr,
ArrayType type) |
static INDArray |
TimeSeriesUtils.reshapeCnnMaskToTimeSeriesMask(INDArray timeSeriesMaskAsCnnMask,
int minibatchSize)
Reshape CNN-style 4d mask array of shape [seqLength*minibatch,1,1,1] to time series mask [mb,seqLength]
This should match the assumptions (f order, etc) in RnnOutputLayer
|
static INDArray |
ConvolutionUtils.reshapeMaskIfRequired(INDArray mask,
INDArray output,
LayerWorkspaceMgr workspaceMgr,
ArrayType type) |
static INDArray |
TimeSeriesUtils.reshapePerOutputTimeSeriesMaskTo2d(INDArray perOutputTimeSeriesMask) |
static INDArray |
TimeSeriesUtils.reshapePerOutputTimeSeriesMaskTo2d(INDArray perOutputTimeSeriesMask,
LayerWorkspaceMgr workspaceMgr,
ArrayType arrayType) |
static INDArray |
TimeSeriesUtils.reshapeTimeSeriesMaskToCnn4dMask(INDArray timeSeriesMask,
LayerWorkspaceMgr workspaceMgr,
ArrayType arrayType)
Reshape time series mask arrays.
|
static INDArray |
TimeSeriesUtils.reshapeTimeSeriesMaskToVector(INDArray timeSeriesMask)
Reshape time series mask arrays.
|
static INDArray |
TimeSeriesUtils.reshapeTimeSeriesMaskToVector(INDArray timeSeriesMask,
LayerWorkspaceMgr workspaceMgr,
ArrayType arrayType)
Reshape time series mask arrays.
|
static INDArray |
TimeSeriesUtils.reshapeVectorToTimeSeriesMask(INDArray timeSeriesMaskAsVector,
int minibatchSize)
Reshape time series mask arrays.
|
static INDArray |
TimeSeriesUtils.reverseTimeSeries(INDArray in)
Reverse an input time series along the time dimension
|
static INDArray |
TimeSeriesUtils.reverseTimeSeries(INDArray in,
LayerWorkspaceMgr workspaceMgr,
ArrayType arrayType)
Reverse an input time series along the time dimension
|
static INDArray |
TimeSeriesUtils.reverseTimeSeriesMask(INDArray mask)
Reverse a (per time step) time series mask, with shape [minibatch, timeSeriesLength]
|
static INDArray |
TimeSeriesUtils.reverseTimeSeriesMask(INDArray mask,
LayerWorkspaceMgr workspaceMgr,
ArrayType arrayType)
Reverse a (per time step) time series mask, with shape [minibatch, timeSeriesLength]
|
static void |
ConvolutionUtils.validateShapes(INDArray inputData,
int[] eKernel,
int[] strides,
int[] padding,
ConvolutionMode convolutionMode,
int[] dilation,
int[] inShape,
boolean atrous) |
static void |
Convolution1DUtils.validateShapes(INDArray inputData,
int eKernel,
int strides,
int padding,
ConvolutionMode convolutionMode,
int dilation,
int inShape,
boolean atrous) |
| Constructor and Description |
|---|
MovingWindowMatrix(INDArray toSlice,
int windowRowSize,
int windowColumnSize)
Same as calling new MovingWindowMatrix(toSlice,windowRowSize,windowColumnSize,false)
|
MovingWindowMatrix(INDArray toSlice,
int windowRowSize,
int windowColumnSize,
boolean addRotate) |
| Modifier and Type | Method and Description |
|---|---|
List<List<ClassPrediction>> |
Labels.decodePredictions(INDArray predictions,
int n)
Given predictions from the trained model this method will return a list
of the top n matches and the respective probabilities.
|
List<List<ClassPrediction>> |
BaseLabels.decodePredictions(INDArray predictions,
int n) |
| Modifier and Type | Method and Description |
|---|---|
String |
ImageNetLabels.decodePredictions(INDArray predictions)
Given predictions from the trained model this method will return a string
listing the top five matches and the respective probabilities
|
| Modifier and Type | Method and Description |
|---|---|
INDArray |
Nd4jSerializer.read(com.esotericsoftware.kryo.Kryo kryo,
com.esotericsoftware.kryo.io.Input input,
Class<INDArray> type)
Reads bytes and returns a new object of the specified concrete opType.
|
| Modifier and Type | Method and Description |
|---|---|
void |
Nd4jSerializer.write(com.esotericsoftware.kryo.Kryo kryo,
com.esotericsoftware.kryo.io.Output output,
INDArray object)
Writes the bytes for the object to the output.
|
| Modifier and Type | Method and Description |
|---|---|
INDArray |
Nd4jSerializer.read(com.esotericsoftware.kryo.Kryo kryo,
com.esotericsoftware.kryo.io.Input input,
Class<INDArray> type)
Reads bytes and returns a new object of the specified concrete opType.
|
| Modifier and Type | Method and Description |
|---|---|
T |
OutputAdapter.apply(INDArray... outputs)
This method provides conversion from multiple INDArrays to T
|
| Modifier and Type | Method and Description |
|---|---|
INDArray |
NDArrayHolder.get()
Retrieve an ndarray
|
INDArray |
NDArrayHolder.getTad(int idx,
int... dimensions)
Retrieve a partial view of the ndarray.
|
static INDArray |
AeronNDArraySerde.toArray(org.agrona.DirectBuffer buffer)
Create an ndarray
from the unsafe buffer
|
static INDArray |
AeronNDArraySerde.toArray(org.agrona.DirectBuffer buffer,
int offset)
Create an ndarray
from the unsafe buffer
|
| Modifier and Type | Method and Description |
|---|---|
static Pair<INDArray,ByteBuffer> |
AeronNDArraySerde.toArrayAndByteBuffer(org.agrona.DirectBuffer buffer,
int offset)
Create an ndarray
from the unsafe buffer.
|
| Modifier and Type | Method and Description |
|---|---|
static NDArrayMessage |
NDArrayMessage.of(INDArray arr,
int[] dimensions,
long index)
Factory method for creating an array
to send now (uses now in utc for the timestamp).
|
void |
NDArrayCallback.onNDArray(INDArray arr)
Setup an ndarray
|
void |
NDArrayCallback.onNDArrayPartial(INDArray arr,
long idx,
int... dimensions)
Used for partial updates using tensor along
dimension
|
void |
AeronNDArrayPublisher.publish(INDArray arr)
Publish an ndarray to an aeron channel
|
void |
NDArrayHolder.setArray(INDArray arr)
Set the ndarray
|
static org.agrona.concurrent.UnsafeBuffer |
AeronNDArraySerde.toBuffer(INDArray arr)
Convert an ndarray to an unsafe buffer
for use by aeron
|
static NDArrayMessage |
NDArrayMessage.wholeArrayUpdate(INDArray arr)
Prepare a whole array update
which includes the default dimensions
for indicating updating
the whole array (a 1 length int array with -1 as its only element)
-1 representing the dimension
|
| Modifier and Type | Method and Description |
|---|---|
INDArray |
InMemoryNDArrayHolder.get()
Retrieve an ndarray
|
INDArray |
InMemoryNDArrayHolder.getTad(int idx,
int... dimensions)
Retrieve a partial view of the ndarray.
|
| Modifier and Type | Method and Description |
|---|---|
void |
InMemoryNDArrayHolder.setArray(INDArray arr)
Set the ndarray
|
| Constructor and Description |
|---|
InMemoryNDArrayHolder(INDArray arr) |
| Modifier and Type | Method and Description |
|---|---|
static INDArray |
ArrowSerde.fromTensor(org.apache.arrow.flatbuf.Tensor tensor)
Convert a
Tensor
to an INDArray |
| Modifier and Type | Method and Description |
|---|---|
static int |
ArrowSerde.addDataForArr(com.google.flatbuffers.FlatBufferBuilder bufferBuilder,
INDArray arr)
Create a
Buffer
representing the location metadata of the actual data
contents for the ndarrays' DataBuffer |
static void |
ArrowSerde.addTypeTypeRelativeToNDArray(com.google.flatbuffers.FlatBufferBuilder bufferBuilder,
INDArray arr)
Convert the given
INDArray
data type to the proper data type for the tensor. |
static int |
ArrowSerde.createDims(com.google.flatbuffers.FlatBufferBuilder bufferBuilder,
INDArray arr)
Create the dimensions for the flatbuffer builder
|
static long[] |
ArrowSerde.getArrowStrides(INDArray arr)
Get the strides of this
INDArray
multiplieed by the element size. |
static org.apache.arrow.flatbuf.Tensor |
ArrowSerde.toTensor(INDArray arr)
Convert an
INDArray
to an arrow Tensor |
| Modifier and Type | Method and Description |
|---|---|
INDArray[] |
NativeGraphExecutioner.executeGraph(int id,
SDVariable... variables)
This method executes
|
INDArray[] |
GraphExecutioner.executeGraph(int id,
SDVariable... variables)
This method executes
|
INDArray[] |
BasicGraphExecutioner.executeGraph(int id,
SDVariable... variables)
This method executes
|
INDArray[] |
NativeGraphExecutioner.executeGraph(SameDiff sd)
This method executes given graph and returns results
PLEASE NOTE: Default configuration is used
|
INDArray[] |
GraphExecutioner.executeGraph(SameDiff graph) |
INDArray[] |
BasicGraphExecutioner.executeGraph(SameDiff sd)
This method executes given graph and returns results
PLEASE NOTE: Default configuration is used
|
INDArray[] |
NativeGraphExecutioner.executeGraph(SameDiff sd,
ExecutorConfiguration configuration)
This method executes given graph and returns results
|
INDArray[] |
GraphExecutioner.executeGraph(SameDiff graph,
ExecutorConfiguration configuration)
This method executes given graph and returns results
|
INDArray[] |
BasicGraphExecutioner.executeGraph(SameDiff graph,
ExecutorConfiguration configuration)
This method executes given graph and returns results
|
INDArray[] |
NativeGraphExecutioner.importProto(File file) |
INDArray[] |
GraphExecutioner.importProto(File file)
This method executes TF graph
PLEASE NOTE: This feature is under development yet
|
INDArray[] |
BasicGraphExecutioner.importProto(File file) |
INDArray[] |
NativeGraphExecutioner.reuseGraph(SameDiff graph,
Map<Integer,INDArray> inputs) |
INDArray[] |
GraphExecutioner.reuseGraph(SameDiff graph,
Map<Integer,INDArray> inputs) |
INDArray[] |
BasicGraphExecutioner.reuseGraph(SameDiff graph,
Map<Integer,INDArray> inputs) |
| Modifier and Type | Method and Description |
|---|---|
INDArray[] |
NativeGraphExecutioner.reuseGraph(SameDiff graph,
Map<Integer,INDArray> inputs) |
INDArray[] |
GraphExecutioner.reuseGraph(SameDiff graph,
Map<Integer,INDArray> inputs) |
INDArray[] |
BasicGraphExecutioner.reuseGraph(SameDiff graph,
Map<Integer,INDArray> inputs) |
| Modifier and Type | Method and Description |
|---|---|
INDArray[] |
Operands.asArray()
This method return operands as array, in order of addition
|
INDArray |
Operands.getById(int id)
This method returns array identified its numeric id
|
INDArray |
Operands.getById(int id,
int index)
This method returns array identified its numeric id and index
|
INDArray |
Operands.getById(String name)
This method returns array identified its name
|
| Modifier and Type | Method and Description |
|---|---|
Collection<Pair<Operands.NodeDescriptor,INDArray>> |
Operands.asCollection()
This method returns contents of this entity as collection of key->value pairs
|
| Modifier and Type | Method and Description |
|---|---|
Operands |
Operands.addArgument(int id,
INDArray array)
This method allows to pass array to the node identified by numeric id
|
Operands |
Operands.addArgument(int id,
int index,
INDArray array)
This method allows to pass array to multi-output node in the graph
|
Operands |
Operands.addArgument(String id,
INDArray array)
This method allows to pass array to the node identified by its name
|
Operands |
Operands.addArgument(String name,
int id,
int index,
INDArray array)
This method allows to pass array to multi-output node in the graph
|
| Modifier and Type | Field and Description |
|---|---|
protected INDArray |
DifferentialFunction.scalarValue |
| Modifier and Type | Method and Description |
|---|---|
INDArray |
DifferentialFunction.getInputArgument(int index) |
| Modifier and Type | Method and Description |
|---|---|
ExternalErrorsFunction |
DifferentialFunctionFactory.externalErrors(Map<String,INDArray> externalGradients,
SDVariable... inputs) |
| Modifier and Type | Method and Description |
|---|---|
void |
Listener.activationAvailable(SameDiff sd,
At at,
MultiDataSet batch,
SameDiffOp op,
String varName,
INDArray activation)
Called when any activation becomes available.
|
void |
BaseListener.activationAvailable(SameDiff sd,
At at,
MultiDataSet batch,
SameDiffOp op,
String varName,
INDArray activation) |
void |
BaseEvaluationListener.activationAvailable(SameDiff sd,
At at,
MultiDataSet batch,
SameDiffOp op,
String varName,
INDArray activation) |
void |
BaseEvaluationListener.activationAvailableEvaluations(SameDiff sd,
At at,
MultiDataSet batch,
SameDiffOp op,
String varName,
INDArray activation)
|
void |
Listener.opExecution(SameDiff sd,
At at,
MultiDataSet batch,
SameDiffOp op,
INDArray[] outputs)
Called at the end of each operation execution
Note: Outputs will most likely be freed later, use detach() if you need to save it. |
void |
BaseListener.opExecution(SameDiff sd,
At at,
MultiDataSet batch,
SameDiffOp op,
INDArray[] outputs) |
void |
Listener.preUpdate(SameDiff sd,
At at,
Variable v,
INDArray update)
Called just before each parameter is to be updated - i.e., just before each parameter is modified.
|
void |
BaseListener.preUpdate(SameDiff sd,
At at,
Variable v,
INDArray update) |
| Modifier and Type | Method and Description |
|---|---|
void |
OpBenchmarkListener.opExecution(SameDiff sd,
At at,
MultiDataSet batch,
SameDiffOp op,
INDArray[] outputs) |
void |
ArraySavingListener.opExecution(SameDiff sd,
At at,
MultiDataSet batch,
SameDiffOp op,
INDArray[] outputs) |
| Modifier and Type | Method and Description |
|---|---|
void |
UIListener.opExecution(SameDiff sd,
At at,
MultiDataSet batch,
SameDiffOp op,
INDArray[] outputs) |
void |
UIListener.preUpdate(SameDiff sd,
At at,
Variable v,
INDArray update) |
| Constructor and Description |
|---|
LossCurve(INDArray lossValues,
List<String> lossNames) |
| Modifier and Type | Method and Description |
|---|---|
INDArray |
SDVariable.eval()
Evaluate the result of this variable
|
INDArray |
SDVariable.eval(Map<String,INDArray> placeholders)
Evaluate the result of this variable
|
INDArray |
SDVariable.getArr()
A getter for the allocated ndarray with this
SDVariable. |
INDArray |
SDVariable.getArr(boolean enforceExistence)
A getter for the allocated ndarray with this
SDVariable. |
INDArray |
ArrayHolder.getArray(String name) |
INDArray |
SameDiff.getArrForVarName(String varName)
Get an
INDArray for a given vertex id, or null if none exists |
INDArray |
SameDiff.outputSingle(Map<String,INDArray> placeholders,
String output)
Do inference for a single variable for a single batch.
|
INDArray |
ArrayHolder.removeArray(String name)
Remove the array from the ArrayHolder, returning it (if it exists)
|
| Modifier and Type | Method and Description |
|---|---|
protected Map<String,INDArray> |
SameDiff.batchOutputHelper(Map<String,INDArray> placeholders,
List<Listener> listeners,
Operation operation,
String... outputs) |
Map<String,INDArray> |
SameDiff.calculateGradients(Map<String,INDArray> placeholderVals,
Collection<String> variables)
Calculate and return the gradients for the specified variables
|
Map<String,INDArray> |
SameDiff.calculateGradients(Map<String,INDArray> placeholderVals,
String... variables)
|
protected Map<String,INDArray> |
SameDiff.directExecHelper(Map<String,INDArray> placeholders,
At at,
MultiDataSet batch,
Collection<String> requiredActivations,
List<Listener> activeListeners,
String... outputs)
Do inference for the given variables for a single batch, with training information
|
Map<String,INDArray> |
SameDiff.output(DataSetIterator iterator,
List<Listener> listeners,
String... outputs)
Do inference on a network with a single input.
|
Map<String,INDArray> |
SameDiff.output(DataSetIterator dataSet,
String... outputs)
|
Map<String,INDArray> |
SameDiff.output(DataSet dataSet,
String... outputs)
Do a single batch inference on a network with a single input.
|
Map<String,INDArray> |
SameDiff.output(Map<String,INDArray> placeholders,
List<Listener> listeners,
String... outputs)
Do inference for the given variables for a single batch.
|
Map<String,INDArray> |
SameDiff.output(Map<String,INDArray> placeholders,
List<String> outputs)
Do inference for the given variables for a single batch.
|
Map<String,INDArray> |
SameDiff.output(Map<String,INDArray> placeholders,
String... outputs)
Do inference for the given variables for a single batch.
|
Map<String,INDArray> |
SameDiff.output(MultiDataSetIterator iterator,
List<Listener> listeners,
String... outputs)
Perform inference.
|
Map<String,INDArray> |
SameDiff.output(MultiDataSetIterator dataSet,
String... outputs)
|
Map<String,INDArray> |
SameDiff.output(MultiDataSet dataSet,
String... outputs)
Do a single batch inference on a network.
|
Map<String,INDArray> |
SameDiff.outputAll(Map<String,INDArray> placeholders)
Do inference for all variables for a single batch.
|
List<Map<String,INDArray>> |
SameDiff.outputBatches(DataSetIterator iterator,
List<Listener> listeners,
String... outputs)
See
SameDiff.output(DataSetIterator, List, String...), but without the concatenation of batches. |
List<Map<String,INDArray>> |
SameDiff.outputBatches(DataSetIterator iterator,
String... outputs)
See
SameDiff.output(DataSetIterator, String...), but without the concatenation of batches. |
List<Map<String,INDArray>> |
SameDiff.outputBatches(MultiDataSetIterator iterator,
List<Listener> listeners,
String... outputs)
Perform inference.
|
List<Map<String,INDArray>> |
SameDiff.outputBatches(MultiDataSetIterator iterator,
String... outputs)
|
| Modifier and Type | Method and Description |
|---|---|
void |
SameDiff.assignArray(INDArray arr,
SDVariable variable)
Update the constant or variable type SDVariable with the values from the specified
array.
|
void |
SameDiff.associateArrayWithVariable(INDArray arr,
SDVariable variable)
Associate the array with the given variable.
|
void |
SameDiff.associateArrayWithVariable(INDArray arr,
String variable)
Associate the array with the given variable.
|
SDVariable |
SameDiff.constant(INDArray constant)
Create an SDVariable with a fixed/constant value, with a generated name
Constants are not modified by training/backprop. |
SDVariable |
SameDiff.constant(String name,
INDArray constant)
Create an SDVariable with a fixed/constant value
Constants are not modified by training/backprop. |
SDVariable |
SDVariable.setArray(INDArray array)
Associate the specified array with this variable
|
void |
ArrayHolder.setArray(String name,
INDArray array)
Set the array for the specified name (new array, or replace if it already exists)
|
void |
SameDiff.setArrayForVariable(String varName,
INDArray arr)
Set the stored
INDArray for a variable. |
SDVariable |
SameDiff.var(INDArray arr)
Create an
SDVariable with a generated name, and assocate the specified array with it. |
SDVariable |
SameDiff.var(String name,
INDArray arr)
Create an
SDVariable with the specified name, and associate the specified array with itThis is a VARIABLE type SDVariable - i.e., must be floating point, and is a trainable parameter. |
| Modifier and Type | Method and Description |
|---|---|
protected Map<String,INDArray> |
SameDiff.batchOutputHelper(Map<String,INDArray> placeholders,
List<Listener> listeners,
Operation operation,
String... outputs) |
Map<String,INDArray> |
SameDiff.calculateGradients(Map<String,INDArray> placeholderVals,
Collection<String> variables)
Calculate and return the gradients for the specified variables
|
Map<String,INDArray> |
SameDiff.calculateGradients(Map<String,INDArray> placeholderVals,
String... variables)
|
OutAndGrad |
SameDiff.calculateGradientsAndOutputs(Map<String,INDArray> placeholderVals,
Collection<String> outputVars,
Collection<String> gradientVars)
Calculate the activations and the gradients for the specified variables, in one execution call.
|
SDVariable[] |
SameDiffFunctionDefinition.define(SameDiff sameDiff,
Map<String,INDArray> inputs,
SDVariable[] variableInputs) |
void |
SameDiff.defineFunction(String function,
SameDiffFunctionDefinition functionDefinition,
Map<String,INDArray> inputs) |
protected Map<String,INDArray> |
SameDiff.directExecHelper(Map<String,INDArray> placeholders,
At at,
MultiDataSet batch,
Collection<String> requiredActivations,
List<Listener> activeListeners,
String... outputs)
Do inference for the given variables for a single batch, with training information
|
INDArray |
SDVariable.eval(Map<String,INDArray> placeholders)
Evaluate the result of this variable
|
Map<String,INDArray> |
SameDiff.output(Map<String,INDArray> placeholders,
List<Listener> listeners,
String... outputs)
Do inference for the given variables for a single batch.
|
Map<String,INDArray> |
SameDiff.output(Map<String,INDArray> placeholders,
List<String> outputs)
Do inference for the given variables for a single batch.
|
Map<String,INDArray> |
SameDiff.output(Map<String,INDArray> placeholders,
String... outputs)
Do inference for the given variables for a single batch.
|
Map<String,INDArray> |
SameDiff.outputAll(Map<String,INDArray> placeholders)
Do inference for all variables for a single batch.
|
INDArray |
SameDiff.outputSingle(Map<String,INDArray> placeholders,
String output)
Do inference for a single variable for a single batch.
|
| Modifier and Type | Method and Description |
|---|---|
INDArray |
ThreadSafeArrayHolder.getArray(String name) |
INDArray |
SingleThreadArrayHolder.getArray(String name) |
INDArray |
ThreadSafeArrayHolder.removeArray(String name) |
INDArray |
SingleThreadArrayHolder.removeArray(String name) |
| Modifier and Type | Method and Description |
|---|---|
void |
ThreadSafeArrayHolder.setArray(String name,
INDArray array) |
void |
SingleThreadArrayHolder.setArray(String name,
INDArray array) |
| Modifier and Type | Method and Description |
|---|---|
INDArray |
OutputConfig.execSingle()
Do inference and return the results for the single output variable specified.
|
INDArray |
BatchOutputConfig.execSingle()
Deprecated.
|
INDArray |
BatchOutputConfig.outputSingle()
Do inference and return the results for the single output
Only works if exactly one output is specified
|
| Modifier and Type | Method and Description |
|---|---|
Map<String,INDArray> |
OutputConfig.exec()
Do inference and return the results.
|
Map<String,INDArray> |
BatchOutputConfig.exec()
Deprecated.
|
List<Map<String,INDArray>> |
OutputConfig.execBatches()
Do inference and return the results in batches.
|
List<INDArray> |
OutputConfig.execSingleBatches()
Do inference and return the results (in batches) for the single output variable specified.
|
Map<String,INDArray> |
BatchOutputConfig.output()
Do inference and return the results
|
| Modifier and Type | Method and Description |
|---|---|
BatchOutputConfig |
BatchOutputConfig.input(SDVariable variable,
INDArray placeholder)
|
BatchOutputConfig |
BatchOutputConfig.input(String variable,
INDArray placeholder)
Add a placeholder value for a specified variable
|
| Modifier and Type | Method and Description |
|---|---|
BatchOutputConfig |
BatchOutputConfig.inputs(Map<String,INDArray> placeholders)
Calls
BatchOutputConfig.input(String, INDArray) on each entry in the map. |
| Modifier and Type | Method and Description |
|---|---|
INDArray |
SessionMemMgr.allocate(boolean detached,
DataType dataType,
long... shape)
Allocate an array with the specified datatype and shape.
|
INDArray |
SessionMemMgr.allocate(boolean detached,
LongShapeDescriptor descriptor)
As per
SessionMemMgr.allocate(boolean, DataType, long...) but from a LongShapeDescriptor instead |
INDArray[] |
InferenceSession.doExec(DifferentialFunction op,
AbstractSession.FrameIter outputFrameIter,
Set<AbstractSession.VarId> opInputs,
Set<AbstractSession.VarId> allIterInputs,
Set<String> constAndPhInputs) |
INDArray |
SessionMemMgr.dup(INDArray arr)
Duplicate the specified array, to an array that is managed/allocated by the session memory manager
|
protected INDArray |
InferenceSession.getArray(SDVariable sdv,
Collection<AbstractSession.VarId> opInputs,
Collection<AbstractSession.VarId> allIterInputs) |
INDArray |
InferenceSession.getConstantOrVariable(String variableName) |
INDArray[] |
TrainingSession.getOutputs(SameDiffOp op,
AbstractSession.FrameIter outputFrameIter,
Set<AbstractSession.VarId> opInputs,
Set<AbstractSession.VarId> allIterInputs,
Set<String> constAndPhInputs,
List<Listener> listeners,
At at,
MultiDataSet batch,
Set<String> allReqVariables) |
INDArray[] |
InferenceSession.getOutputs(SameDiffOp op,
AbstractSession.FrameIter outputFrameIter,
Set<AbstractSession.VarId> opInputs,
Set<AbstractSession.VarId> allIterInputs,
Set<String> constAndPhInputs,
List<Listener> listeners,
At at,
MultiDataSet batch,
Set<String> allReqVariables) |
INDArray[] |
InferenceSession.getOutputsHelperTensorArrayOps(DifferentialFunction op,
AbstractSession.FrameIter outputFrameIter,
Set<AbstractSession.VarId> opInputs,
Set<AbstractSession.VarId> allIterInputs)
Forward pass for TensorArray ops
|
INDArray |
SessionMemMgr.ulike(INDArray arr)
Allocate an uninitialized array with the same datatype and shape as the specified array
|
| Modifier and Type | Method and Description |
|---|---|
protected Map<String,INDArray> |
InferenceSession.postProcessOutput(Map<String,INDArray> output) |
protected Map<String,INDArray> |
InferenceSession.preprocessPlaceholders(Map<String,INDArray> placeholders,
At at) |
| Modifier and Type | Method and Description |
|---|---|
INDArray |
SessionMemMgr.dup(INDArray arr)
Duplicate the specified array, to an array that is managed/allocated by the session memory manager
|
void |
SessionMemMgr.release(INDArray array)
Release the array.
|
INDArray |
SessionMemMgr.ulike(INDArray arr)
Allocate an uninitialized array with the same datatype and shape as the specified array
|
| Modifier and Type | Method and Description |
|---|---|
SameDiffOp |
InferenceSession.getAndParameterizeOp(String opName,
AbstractSession.FrameIter frameIter,
Set<AbstractSession.VarId> opInputs,
Set<AbstractSession.VarId> allIterInputs,
Set<String> constAndPhInputs,
Map<String,INDArray> placeholderValues,
Set<String> allReqVariables) |
protected Map<String,INDArray> |
InferenceSession.postProcessOutput(Map<String,INDArray> output) |
protected Map<String,INDArray> |
InferenceSession.preprocessPlaceholders(Map<String,INDArray> placeholders,
At at) |
Loss |
TrainingSession.trainingIteration(TrainingConfig config,
Map<String,INDArray> placeholders,
Set<String> paramsToTrain,
Map<String,GradientUpdater> updaters,
MultiDataSet batch,
List<String> lossVariables,
List<Listener> listeners,
At at)
Perform one iteration of training - i.e., do forward and backward passes, and update the parameters
|
| Modifier and Type | Method and Description |
|---|---|
INDArray |
NoOpMemoryMgr.allocate(boolean detached,
DataType dataType,
long... shape) |
INDArray |
CloseValidationMemoryMgr.allocate(boolean detached,
DataType dataType,
long... shape) |
INDArray |
ArrayCloseMemoryMgr.allocate(boolean detached,
DataType dataType,
long... shape) |
INDArray |
ArrayCacheMemoryMgr.allocate(boolean detached,
DataType dataType,
long... shape) |
INDArray |
NoOpMemoryMgr.allocate(boolean detached,
LongShapeDescriptor descriptor) |
INDArray |
CloseValidationMemoryMgr.allocate(boolean detached,
LongShapeDescriptor descriptor) |
INDArray |
ArrayCloseMemoryMgr.allocate(boolean detached,
LongShapeDescriptor descriptor) |
INDArray |
ArrayCacheMemoryMgr.allocate(boolean detached,
LongShapeDescriptor descriptor) |
INDArray |
AbstractMemoryMgr.dup(INDArray arr) |
INDArray |
AbstractMemoryMgr.ulike(INDArray arr) |
| Modifier and Type | Method and Description |
|---|---|
protected Set<INDArray> |
CloseValidationMemoryMgr.identitySetAllConstPhVar() |
| Modifier and Type | Method and Description |
|---|---|
INDArray |
AbstractMemoryMgr.dup(INDArray arr) |
void |
NoOpMemoryMgr.release(INDArray array) |
void |
CloseValidationMemoryMgr.release(INDArray array) |
void |
ArrayCloseMemoryMgr.release(INDArray array) |
void |
ArrayCacheMemoryMgr.release(INDArray array) |
INDArray |
AbstractMemoryMgr.ulike(INDArray arr) |
| Modifier and Type | Method and Description |
|---|---|
void |
CloseValidationMemoryMgr.assertAllReleasedExcept(Collection<INDArray> except)
Check that all arrays have been released (after an inference call) except for the specified arrays.
|
| Modifier and Type | Method and Description |
|---|---|
static List<INDArray> |
TrainingUtils.getSingleOutput(List<Map<String,INDArray>> outputs,
String output)
Get a list of batch outputs for a single variable from a list of batch outputs for all variables
|
static Map<String,INDArray> |
TrainingUtils.stackOutputs(List<Map<String,INDArray>> outputs)
Stack batch outputs, like an output from
SameDiff.output(MultiDataSetIterator, String...) |
| Modifier and Type | Method and Description |
|---|---|
static List<INDArray> |
TrainingUtils.getSingleOutput(List<Map<String,INDArray>> outputs,
String output)
Get a list of batch outputs for a single variable from a list of batch outputs for all variables
|
static Map<String,INDArray> |
TrainingUtils.stackOutputs(List<Map<String,INDArray>> outputs)
Stack batch outputs, like an output from
SameDiff.output(MultiDataSetIterator, String...) |
| Modifier and Type | Method and Description |
|---|---|
Map<String,INDArray> |
TestCase.gradCheckMask() |
| Modifier and Type | Method and Description |
|---|---|
TestCase |
TestCase.expected(SDVariable var,
INDArray output)
Validate the output (forward pass) for a single variable using INDArray.equals(INDArray)
|
TestCase |
TestCase.expected(String name,
INDArray output)
Validate the output (forward pass) for a single variable using INDArray.equals(INDArray)
|
OpTestCase |
OpTestCase.expectedOutput(int outputNum,
INDArray expected)
Validate the op output using INDArray.equals(INDArray)
|
TestCase |
TestCase.expectedOutput(String name,
INDArray expected)
Validate the output (forward pass) for a single variable using INDArray.equals(INDArray)
|
OpTestCase |
OpTestCase.expectedOutputRelError(int outputNum,
INDArray expected,
double maxRelError,
double minAbsError)
Validate the output for a single variable using element-wise relative error:
relError = abs(x-y)/(abs(x)+abs(y)), with x=y=0 case defined to be 0.0.
|
TestCase |
TestCase.expectedOutputRelError(String name,
INDArray expected,
double maxRelError,
double minAbsError)
Validate the output (forward pass) for a single variable using element-wise relative error:
relError = abs(x-y)/(abs(x)+abs(y)), with x=y=0 case defined to be 0.0.
|
void |
ActivationGradientCheckListener.opExecution(SameDiff sd,
At at,
MultiDataSet batch,
SameDiffOp op,
INDArray[] outputs) |
TestCase |
TestCase.placeholderValue(String variable,
INDArray value) |
| Modifier and Type | Method and Description |
|---|---|
static boolean |
GradCheckUtil.checkGradients(SameDiff sd,
Map<String,INDArray> placeholderValues,
boolean print,
boolean exitOnFirstFailure) |
static boolean |
GradCheckUtil.checkGradients(SameDiff sd,
Map<String,INDArray> placeholderValues,
double eps,
double maxRelError,
double minAbsError,
boolean print,
boolean exitOnFirstFailure) |
static boolean |
GradCheckUtil.checkGradients(SameDiff sd,
Map<String,INDArray> placeholderValues,
double eps,
double maxRelError,
double minAbsError,
boolean print,
boolean exitOnFirstFailure,
boolean skipValidation,
boolean debugMode,
Set<String> skipVariables,
Map<String,INDArray> gradCheckMask) |
static boolean |
GradCheckUtil.checkGradients(SameDiff sd,
Map<String,INDArray> placeholderValues,
double eps,
double maxRelError,
double minAbsError,
boolean print,
boolean exitOnFirstFailure,
boolean skipValidation,
boolean debugMode,
Set<String> skipVariables,
Map<String,INDArray> gradCheckMask) |
static boolean |
GradCheckUtil.checkGradients(SameDiff sd,
Map<String,INDArray> placeholderValues,
double eps,
double maxRelError,
double minAbsError,
boolean print,
boolean exitOnFirstFailure,
boolean skipValidation,
boolean debugMode,
Set<String> skipVariables,
Map<String,INDArray> gradCheckMask,
int maxPerParam,
GradCheckUtil.Subset subset) |
static boolean |
GradCheckUtil.checkGradients(SameDiff sd,
Map<String,INDArray> placeholderValues,
double eps,
double maxRelError,
double minAbsError,
boolean print,
boolean exitOnFirstFailure,
boolean skipValidation,
boolean debugMode,
Set<String> skipVariables,
Map<String,INDArray> gradCheckMask,
int maxPerParam,
GradCheckUtil.Subset subset) |
static boolean |
GradCheckUtil.checkGradients(SameDiff sd,
Map<String,INDArray> placeholderValues,
String... skipVariables) |
TestCase |
TestCase.expected(SDVariable var,
Function<INDArray,String> validationFn) |
TestCase |
TestCase.expected(String name,
Function<INDArray,String> validationFn) |
OpTestCase |
OpTestCase.expectedOutput(int outputNum,
LongShapeDescriptor expShape,
Function<INDArray,String> validationFn) |
TestCase |
TestCase.placeholderValues(Map<String,INDArray> placeholderValues) |
| Modifier and Type | Method and Description |
|---|---|
String |
RelErrorFn.apply(INDArray actual) |
String |
EqualityFn.apply(INDArray actual) |
| Modifier and Type | Field and Description |
|---|---|
protected INDArray[] |
NonInplaceValidationListener.opInputs |
protected INDArray[] |
NonInplaceValidationListener.opInputsOrig |
| Modifier and Type | Method and Description |
|---|---|
void |
NonInplaceValidationListener.opExecution(SameDiff sd,
At at,
MultiDataSet batch,
SameDiffOp op,
INDArray[] outputs) |
| Modifier and Type | Method and Description |
|---|---|
INDArray |
Nd4jKafkaConsumer.receive()
Receive an ndarray
|
| Modifier and Type | Method and Description |
|---|---|
void |
Nd4jKafkaProducer.publish(INDArray arr)
Publish to a kafka topic
based on the connection information
|
| Modifier and Type | Method and Description |
|---|---|
INDArray |
AbstractCompressor.compress(double[] data)
This method creates compressed INDArray from Java double array, skipping usual INDArray instantiation routines
Please note: This method compresses input data as vector
|
INDArray |
AbstractCompressor.compress(double[] data,
int[] shape,
char order)
This method creates compressed INDArray from Java double array, skipping usual INDArray instantiation routines
|
INDArray |
AbstractCompressor.compress(float[] data)
This method creates compressed INDArray from Java float array, skipping usual INDArray instantiation routines
Please note: This method compresses input data as vector
|
INDArray |
AbstractCompressor.compress(float[] data,
int[] shape,
char order)
This method creates compressed INDArray from Java float array, skipping usual INDArray instantiation routines
|
INDArray |
AbstractCompressor.compress(INDArray array) |
INDArray |
AbstractCompressor.decompress(INDArray array) |
| Modifier and Type | Method and Description |
|---|---|
INDArray |
AbstractCompressor.compress(INDArray array) |
void |
AbstractCompressor.compressi(INDArray array)
Inplace compression of INDArray
|
INDArray |
AbstractCompressor.decompress(INDArray array) |
void |
AbstractCompressor.decompressi(INDArray array) |
| Modifier and Type | Method and Description |
|---|---|
static INDArray |
EvaluationUtils.reshapeTimeSeriesMaskToVector(INDArray timeSeriesMask)
Reshape time series mask arrays.
|
static INDArray |
EvaluationUtils.reshapeTimeSeriesTo2d(INDArray labels) |
| Modifier and Type | Method and Description |
|---|---|
static Pair<INDArray,INDArray> |
EvaluationUtils.extractNonMaskedTimeSteps(INDArray labels,
INDArray predicted,
INDArray outputMask) |
static Pair<INDArray,INDArray> |
EvaluationUtils.extractNonMaskedTimeSteps(INDArray labels,
INDArray predicted,
INDArray outputMask) |
static Triple<INDArray,INDArray,INDArray> |
BaseEvaluation.reshapeAndExtractNotMasked(INDArray labels,
INDArray predictions,
INDArray mask,
int axis) |
static Triple<INDArray,INDArray,INDArray> |
BaseEvaluation.reshapeAndExtractNotMasked(INDArray labels,
INDArray predictions,
INDArray mask,
int axis) |
static Triple<INDArray,INDArray,INDArray> |
BaseEvaluation.reshapeAndExtractNotMasked(INDArray labels,
INDArray predictions,
INDArray mask,
int axis) |
| Modifier and Type | Method and Description |
|---|---|
void |
IEvaluation.eval(INDArray labels,
INDArray networkPredictions) |
void |
BaseEvaluation.eval(INDArray labels,
INDArray networkPredictions) |
void |
IEvaluation.eval(INDArray labels,
INDArray networkPredictions,
INDArray maskArray) |
void |
BaseEvaluation.eval(INDArray labels,
INDArray networkPredictions,
INDArray maskArray) |
void |
IEvaluation.eval(INDArray labels,
INDArray networkPredictions,
INDArray maskArray,
List<? extends Serializable> recordMetaData) |
void |
IEvaluation.eval(INDArray labels,
INDArray networkPredictions,
List<? extends Serializable> recordMetaData) |
void |
BaseEvaluation.eval(INDArray labels,
INDArray predictions,
List<? extends Serializable> recordMetaData) |
void |
IEvaluation.evalTimeSeries(INDArray labels,
INDArray predicted)
Deprecated.
|
void |
BaseEvaluation.evalTimeSeries(INDArray labels,
INDArray predicted) |
void |
IEvaluation.evalTimeSeries(INDArray labels,
INDArray predicted,
INDArray labelsMaskArray)
Deprecated.
|
void |
BaseEvaluation.evalTimeSeries(INDArray labels,
INDArray predictions,
INDArray labelsMask) |
static Pair<INDArray,INDArray> |
EvaluationUtils.extractNonMaskedTimeSteps(INDArray labels,
INDArray predicted,
INDArray outputMask) |
static Triple<INDArray,INDArray,INDArray> |
BaseEvaluation.reshapeAndExtractNotMasked(INDArray labels,
INDArray predictions,
INDArray mask,
int axis) |
static INDArray |
EvaluationUtils.reshapeTimeSeriesMaskToVector(INDArray timeSeriesMask)
Reshape time series mask arrays.
|
static INDArray |
EvaluationUtils.reshapeTimeSeriesTo2d(INDArray labels) |
| Modifier and Type | Field and Description |
|---|---|
protected INDArray |
Evaluation.costArray |
| Modifier and Type | Method and Description |
|---|---|
protected INDArray |
ROC.getProbAndLabelUsed() |
| Modifier and Type | Method and Description |
|---|---|
void |
EvaluationCalibration.eval(INDArray labels,
INDArray networkPredictions) |
void |
EvaluationBinary.eval(INDArray labels,
INDArray networkPredictions) |
void |
Evaluation.eval(INDArray realOutcomes,
INDArray guesses)
Collects statistics on the real outcomes vs the
guesses.
|
void |
EvaluationCalibration.eval(INDArray labels,
INDArray predictions,
INDArray mask) |
void |
EvaluationBinary.eval(INDArray labelsArr,
INDArray predictionsArr,
INDArray maskArr) |
void |
ROCMultiClass.eval(INDArray labels,
INDArray predictions,
INDArray mask,
List<? extends Serializable> recordMetaData)
Evaluate the network, with optional metadata
|
void |
ROCBinary.eval(INDArray labels,
INDArray predictions,
INDArray mask,
List<? extends Serializable> recordMetaData) |
void |
ROC.eval(INDArray labels,
INDArray predictions,
INDArray mask,
List<? extends Serializable> recordMetaData)
Evaluate (collect statistics for) the given minibatch of data.
|
void |
EvaluationCalibration.eval(INDArray labels,
INDArray networkPredictions,
INDArray maskArray,
List<? extends Serializable> recordMetaData) |
void |
EvaluationBinary.eval(INDArray labels,
INDArray networkPredictions,
INDArray maskArray,
List<? extends Serializable> recordMetaData) |
void |
Evaluation.eval(INDArray labels,
INDArray predictions,
INDArray mask,
List<? extends Serializable> recordMetaData)
Evaluate the network, with optional metadata
|
| Constructor and Description |
|---|
Evaluation(INDArray costArray)
Created evaluation instance with the specified cost array.
|
Evaluation(int axis,
Integer binaryPositiveClass,
int topN,
List<String> labelsList,
Double binaryDecisionThreshold,
INDArray costArray,
int maxWarningClassesToPrint) |
Evaluation(List<String> labels,
INDArray costArray)
Created evaluation instance with the specified cost array.
|
EvaluationBinary(INDArray decisionThreshold)
Create an EvaulationBinary instance with an optional decision threshold array.
|
EvaluationBinary(int axis,
ROCBinary rocBinary,
List<String> labels,
INDArray decisionThreshold) |
| Modifier and Type | Method and Description |
|---|---|
T |
EvaluationLambda.eval(INDArray labels,
INDArray networkPredictions,
INDArray maskArray,
List<? extends Serializable> recordMetaData) |
void |
CustomEvaluation.eval(INDArray labels,
INDArray networkPredictions,
INDArray maskArray,
List<? extends Serializable> recordMetaData) |
| Modifier and Type | Method and Description |
|---|---|
void |
RegressionEvaluation.eval(INDArray labels,
INDArray predictions) |
void |
RegressionEvaluation.eval(INDArray labelsArr,
INDArray predictionsArr,
INDArray maskArr) |
void |
RegressionEvaluation.eval(INDArray labels,
INDArray networkPredictions,
INDArray maskArray,
List<? extends Serializable> recordMetaData) |
| Modifier and Type | Method and Description |
|---|---|
INDArray[] |
GraphInferenceGrpcClient.output(long graphId,
Pair<String,INDArray>... inputs)
This method sends inference request to the GraphServer instance, and returns result as array of INDArrays
|
INDArray[] |
GraphInferenceGrpcClient.output(Pair<String,INDArray>... inputs)
This method sends inference request to the GraphServer instance, and returns result as array of INDArrays
PLEASE NOTE: This call will be routed to default graph with id 0
|
| Modifier and Type | Method and Description |
|---|---|
long |
LogFileWriter.writeHistogramEventCustomBins(String name,
LogFileWriter.EventSubtype subtype,
long time,
int iteration,
int epoch,
INDArray bins,
INDArray y) |
long |
LogFileWriter.writeHistogramEventDiscrete(String name,
LogFileWriter.EventSubtype subtype,
long time,
int iteration,
int epoch,
List<String> binLabels,
INDArray y) |
long |
LogFileWriter.writeHistogramEventEqualSpacing(String name,
LogFileWriter.EventSubtype subtype,
long time,
int iteration,
int epoch,
double min,
double max,
INDArray y) |
| Modifier and Type | Method and Description |
|---|---|
static INDArray |
TFGraphMapper.getArrayFrom(NodeDef nodeDef,
GraphDef graph)
Deprecated.
|
static INDArray |
TFGraphMapper.getNDArrayFromTensor(NodeDef node)
Convert the tensor to an NDArray (if possible and if array is available)
|
static INDArray |
TFGraphMapper.mapTensorProto(TensorProto tfTensor)
Convert a TensorProto to an INDArray
|
| Modifier and Type | Method and Description |
|---|---|
INDArray |
TFTensorMappers.BoolTensorMapper.arrayFor(long[] shape,
boolean[] jArr) |
INDArray |
TFTensorMappers.Float64TensorMapper.arrayFor(long[] shape,
double[] jArr) |
INDArray |
TFTensorMappers.Float16TensorMapper.arrayFor(long[] shape,
float[] jArr) |
INDArray |
TFTensorMappers.Float32TensorMapper.arrayFor(long[] shape,
float[] jArr) |
INDArray |
TFTensorMappers.BFloat16TensorMapper.arrayFor(long[] shape,
float[] jArr) |
INDArray |
TFTensorMappers.Int8TensorMapper.arrayFor(long[] shape,
int[] jArr) |
INDArray |
TFTensorMappers.Int16TensorMapper.arrayFor(long[] shape,
int[] jArr) |
INDArray |
TFTensorMappers.Int32TensorMapper.arrayFor(long[] shape,
int[] jArr) |
INDArray |
TFTensorMappers.UInt8TensorMapper.arrayFor(long[] shape,
int[] jArr) |
INDArray |
TFTensorMappers.UInt16TensorMapper.arrayFor(long[] shape,
int[] jArr) |
INDArray |
TFTensorMapper.arrayFor(long[] shape,
J jArr) |
INDArray |
TFTensorMappers.Int64TensorMapper.arrayFor(long[] shape,
long[] jArr) |
INDArray |
TFTensorMappers.UInt32TensorMapper.arrayFor(long[] shape,
long[] jArr) |
INDArray |
TFTensorMappers.UInt64TensorMapper.arrayFor(long[] shape,
long[] jArr) |
INDArray |
TFTensorMappers.StringTensorMapper.arrayFor(long[] shape,
String[] jArr) |
INDArray |
TFTensorMappers.BaseTensorMapper.toNDArray() |
INDArray |
TFTensorMapper.toNDArray() |
| Modifier and Type | Method and Description |
|---|---|
INDArray |
JDBCNDArrayIO.load(Blob blob)
Load an ndarray from a blob
|
INDArray |
JDBCNDArrayIO.loadArrayForId(String id)
Loads an array for the given id.
|
| Modifier and Type | Method and Description |
|---|---|
Blob |
JDBCNDArrayIO.convert(INDArray toConvert)
Convert an ndarray to a blob
|
void |
JDBCNDArrayIO.save(INDArray save,
String id)
Save the ndarray
|
| Modifier and Type | Method and Description |
|---|---|
INDArray |
BaseLoader.load(Blob blob)
Load an ndarray from a blob
|
INDArray |
BaseLoader.loadArrayForId(String id) |
| Modifier and Type | Method and Description |
|---|---|
Blob |
BaseLoader.convert(INDArray toConvert)
Convert an ndarray to a blob
|
void |
BaseLoader.save(INDArray save,
String id)
Save the ndarray
|
| Modifier and Type | Method and Description |
|---|---|
INDArray |
IActivation.getActivation(INDArray in,
boolean training)
Carry out activation function on the input array (usually known as 'preOut' or 'z')
Implementations must overwrite "in", transform in place and return "in"
Can support separate behaviour during test
|
| Modifier and Type | Method and Description |
|---|---|
Pair<INDArray,INDArray> |
IActivation.backprop(INDArray in,
INDArray epsilon)
Backpropagate the errors through the activation function, given input z and epsilon dL/da.
|
Pair<INDArray,INDArray> |
IActivation.backprop(INDArray in,
INDArray epsilon)
Backpropagate the errors through the activation function, given input z and epsilon dL/da.
|
| Modifier and Type | Method and Description |
|---|---|
protected void |
BaseActivationFunction.assertShape(INDArray in,
INDArray epsilon) |
Pair<INDArray,INDArray> |
IActivation.backprop(INDArray in,
INDArray epsilon)
Backpropagate the errors through the activation function, given input z and epsilon dL/da.
|
INDArray |
IActivation.getActivation(INDArray in,
boolean training)
Carry out activation function on the input array (usually known as 'preOut' or 'z')
Implementations must overwrite "in", transform in place and return "in"
Can support separate behaviour during test
|
| Modifier and Type | Method and Description |
|---|---|
INDArray |
ActivationThresholdedReLU.getActivation(INDArray in,
boolean training) |
INDArray |
ActivationTanH.getActivation(INDArray in,
boolean training) |
INDArray |
ActivationSwish.getActivation(INDArray in,
boolean training) |
INDArray |
ActivationSoftSign.getActivation(INDArray in,
boolean training) |
INDArray |
ActivationSoftPlus.getActivation(INDArray in,
boolean training) |
INDArray |
ActivationSoftmax.getActivation(INDArray in,
boolean training) |
INDArray |
ActivationSigmoid.getActivation(INDArray in,
boolean training) |
INDArray |
ActivationSELU.getActivation(INDArray in,
boolean training) |
INDArray |
ActivationRReLU.getActivation(INDArray in,
boolean training) |
INDArray |
ActivationReLU6.getActivation(INDArray in,
boolean training) |
INDArray |
ActivationReLU.getActivation(INDArray in,
boolean training) |
INDArray |
ActivationRectifiedTanh.getActivation(INDArray in,
boolean training) |
INDArray |
ActivationRationalTanh.getActivation(INDArray in,
boolean training) |
INDArray |
ActivationPReLU.getActivation(INDArray in,
boolean training) |
INDArray |
ActivationMish.getActivation(INDArray in,
boolean training) |
INDArray |
ActivationLReLU.getActivation(INDArray in,
boolean training) |
INDArray |
ActivationIdentity.getActivation(INDArray in,
boolean training) |
INDArray |
ActivationHardTanH.getActivation(INDArray in,
boolean training) |
INDArray |
ActivationHardSigmoid.getActivation(INDArray in,
boolean training) |
INDArray |
ActivationGELU.getActivation(INDArray in,
boolean training) |
INDArray |
ActivationELU.getActivation(INDArray in,
boolean training) |
INDArray |
ActivationCube.getActivation(INDArray in,
boolean training) |
| Modifier and Type | Method and Description |
|---|---|
Pair<INDArray,INDArray> |
ActivationThresholdedReLU.backprop(INDArray in,
INDArray epsilon) |
Pair<INDArray,INDArray> |
ActivationTanH.backprop(INDArray in,
INDArray epsilon) |
Pair<INDArray,INDArray> |
ActivationSwish.backprop(INDArray in,
INDArray epsilon) |
Pair<INDArray,INDArray> |
ActivationSoftSign.backprop(INDArray in,
INDArray epsilon) |
Pair<INDArray,INDArray> |
ActivationSoftPlus.backprop(INDArray in,
INDArray epsilon) |
Pair<INDArray,INDArray> |
ActivationSoftmax.backprop(INDArray in,
INDArray epsilon) |
Pair<INDArray,INDArray> |
ActivationSigmoid.backprop(INDArray in,
INDArray epsilon) |
Pair<INDArray,INDArray> |
ActivationSELU.backprop(INDArray in,
INDArray epsilon) |
Pair<INDArray,INDArray> |
ActivationRReLU.backprop(INDArray in,
INDArray epsilon) |
Pair<INDArray,INDArray> |
ActivationReLU6.backprop(INDArray in,
INDArray epsilon) |
Pair<INDArray,INDArray> |
ActivationReLU.backprop(INDArray in,
INDArray epsilon) |
Pair<INDArray,INDArray> |
ActivationRectifiedTanh.backprop(INDArray in,
INDArray epsilon) |
Pair<INDArray,INDArray> |
ActivationRationalTanh.backprop(INDArray in,
INDArray epsilon) |
Pair<INDArray,INDArray> |
ActivationPReLU.backprop(INDArray in,
INDArray epsilon) |
Pair<INDArray,INDArray> |
ActivationMish.backprop(INDArray in,
INDArray epsilon) |
Pair<INDArray,INDArray> |
ActivationLReLU.backprop(INDArray in,
INDArray epsilon) |
Pair<INDArray,INDArray> |
ActivationIdentity.backprop(INDArray in,
INDArray epsilon) |
Pair<INDArray,INDArray> |
ActivationHardTanH.backprop(INDArray in,
INDArray epsilon) |
Pair<INDArray,INDArray> |
ActivationHardSigmoid.backprop(INDArray in,
INDArray epsilon) |
Pair<INDArray,INDArray> |
ActivationGELU.backprop(INDArray in,
INDArray epsilon) |
Pair<INDArray,INDArray> |
ActivationELU.backprop(INDArray in,
INDArray epsilon) |
Pair<INDArray,INDArray> |
ActivationCube.backprop(INDArray in,
INDArray epsilon) |
INDArray |
ActivationThresholdedReLU.getActivation(INDArray in,
boolean training) |
INDArray |
ActivationTanH.getActivation(INDArray in,
boolean training) |
INDArray |
ActivationSwish.getActivation(INDArray in,
boolean training) |
INDArray |
ActivationSoftSign.getActivation(INDArray in,
boolean training) |
INDArray |
ActivationSoftPlus.getActivation(INDArray in,
boolean training) |
INDArray |
ActivationSoftmax.getActivation(INDArray in,
boolean training) |
INDArray |
ActivationSigmoid.getActivation(INDArray in,
boolean training) |
INDArray |
ActivationSELU.getActivation(INDArray in,
boolean training) |
INDArray |
ActivationRReLU.getActivation(INDArray in,
boolean training) |
INDArray |
ActivationReLU6.getActivation(INDArray in,
boolean training) |
INDArray |
ActivationReLU.getActivation(INDArray in,
boolean training) |
INDArray |
ActivationRectifiedTanh.getActivation(INDArray in,
boolean training) |
INDArray |
ActivationRationalTanh.getActivation(INDArray in,
boolean training) |
INDArray |
ActivationPReLU.getActivation(INDArray in,
boolean training) |
INDArray |
ActivationMish.getActivation(INDArray in,
boolean training) |
INDArray |
ActivationLReLU.getActivation(INDArray in,
boolean training) |
INDArray |
ActivationIdentity.getActivation(INDArray in,
boolean training) |
INDArray |
ActivationHardTanH.getActivation(INDArray in,
boolean training) |
INDArray |
ActivationHardSigmoid.getActivation(INDArray in,
boolean training) |
INDArray |
ActivationGELU.getActivation(INDArray in,
boolean training) |
INDArray |
ActivationELU.getActivation(INDArray in,
boolean training) |
INDArray |
ActivationCube.getActivation(INDArray in,
boolean training) |
| Constructor and Description |
|---|
ActivationPReLU(INDArray alpha,
long[] sharedAxes) |
| Modifier and Type | Method and Description |
|---|---|
INDArray |
Lapack.getLFactor(INDArray A)
extracts the L (lower triangular) matrix from the LU factor result
L will be the same dimensions as A
|
INDArray |
Lapack.getPFactor(int M,
INDArray ipiv)
This method takes one of the ipiv returns from LAPACK and creates
the permutation matrix.
|
INDArray |
Lapack.getrf(INDArray A)
LU decomposiiton of a matrix
Factorize a matrix A
The matrix A is overridden by the L & U combined.
|
INDArray |
Lapack.getUFactor(INDArray A)
extracts the U (upper triangular) matrix from the LU factor result
U will be n x n matrix where n = num cols in A
|
| Modifier and Type | Method and Description |
|---|---|
double |
Level1.asum(INDArray arr)
computes the sum of magnitudes of all vector elements or, for a complex vector x, the sum
|
void |
Level1.axpy(long N,
double alpha,
INDArray x,
INDArray y)
computes a vector-scalar product and adds the result to a vector.
|
void |
Level1.copy(INDArray x,
INDArray y)
copy a vector to another vector.
|
double |
Level1.dot(long N,
double alpha,
INDArray X,
INDArray Y)
computes a vector-vector dot product.
|
void |
Level2.gbmv(char order,
char TransA,
int KL,
int KU,
double alpha,
INDArray A,
INDArray X,
double beta,
INDArray Y)
gbmv computes a matrix-vector product using a general band matrix and performs one of the following matrix-vector operations:
y := alpha*a*x + beta*y for trans = 'N'or'n';
y := alpha*a'*x + beta*y for trans = 'T'or't';
y := alpha*conjg(a')*x + beta*y for trans = 'C'or'c'.
|
void |
Level3.gemm(char Order,
char TransA,
char TransB,
double alpha,
INDArray A,
INDArray B,
double beta,
INDArray C)
gemm performs a matrix-matrix operation
c := alpha*op(a)*op(b) + beta*c,
where c is an m-by-n matrix,
op(a) is an m-by-k matrix,
op(b) is a k-by-n matrix.
|
void |
Level3.gemm(INDArray A,
INDArray B,
INDArray C,
boolean transposeA,
boolean transposeB,
double alpha,
double beta)
A convenience method for matrix-matrix operations with transposes.
|
void |
Level2.gemv(char order,
char transA,
double alpha,
INDArray A,
INDArray X,
double beta,
INDArray Y)
gemv computes a matrix-vector product using a general matrix and performs one of the following matrix-vector operations:
y := alpha*a*x + beta*y for trans = 'N'or'n';
y := alpha*a'*x + beta*y for trans = 'T'or't';
y := alpha*conjg(a')*x + beta*y for trans = 'C'or'c'.
|
void |
Lapack.geqrf(INDArray A,
INDArray R)
QR decomposiiton of a matrix
Factorize a matrix A such that A = QR
The matrix A is overwritten by the Q component (i.e. destroyed)
geqrf = QR factorization of a general matrix (GE) into an orthogonal
matrix Q and an upper triangular R matrix
|
void |
Level2.ger(char order,
double alpha,
INDArray X,
INDArray Y,
INDArray A)
performs a rank-1 update of a general m-by-n matrix a:
a := alpha*x*y' + a.
|
void |
Lapack.gesvd(INDArray A,
INDArray S,
INDArray U,
INDArray VT)
SVD decomposiiton of a matrix
Factorize a matrix into its singular vectors and eigenvalues
The decomposition is such that:
A = U x S x VT
gesvd = singular value decomposition (SVD) of a general matrix (GE)
|
static long |
BlasBufferUtil.getBlasOffset(INDArray arr)
Get blas stride for the
given array
|
static int |
BlasBufferUtil.getBlasStride(INDArray arr)
Get blas stride for the
given array
|
static char |
BlasBufferUtil.getCharForTranspose(INDArray arr)
Returns the proper character for
how to interpret a buffer (fortran being N C being T)
|
static long |
BlasBufferUtil.getDimension(INDArray arr,
boolean defaultRows)
Get the dimension associated with
the given ordering.
|
static double[] |
BlasBufferUtil.getDoubleData(INDArray buf)
Returns the double data
for this ndarray.
|
static float[] |
BlasBufferUtil.getFloatData(INDArray buf)
Returns the float data
for this ndarray.
|
static int |
BlasBufferUtil.getLd(INDArray arr)
Get the leading dimension
for a blas invocation.
|
INDArray |
Lapack.getLFactor(INDArray A)
extracts the L (lower triangular) matrix from the LU factor result
L will be the same dimensions as A
|
INDArray |
Lapack.getPFactor(int M,
INDArray ipiv)
This method takes one of the ipiv returns from LAPACK and creates
the permutation matrix.
|
INDArray |
Lapack.getrf(INDArray A)
LU decomposiiton of a matrix
Factorize a matrix A
The matrix A is overridden by the L & U combined.
|
void |
Lapack.getri(int N,
INDArray A,
int lda,
int[] IPIV,
INDArray WORK,
int lwork,
int INFO)
Generate inverse ggiven LU decomp
|
static int |
BlasBufferUtil.getStrideForOrdering(INDArray arr)
Return the proper stride
through a vector
relative to the ordering of the array
This is for incX/incY parameters in BLAS.
|
INDArray |
Lapack.getUFactor(INDArray A)
extracts the U (upper triangular) matrix from the LU factor result
U will be n x n matrix where n = num cols in A
|
int |
Level1.iamax(INDArray arr)
finds the element of a
vector that has the largest absolute value.
|
int |
Level1.iamax(long N,
INDArray arr,
int stride)
finds the element of a
vector that has the largest absolute value.
|
int |
Level1.iamin(INDArray arr)
finds the element of a vector that has the minimum absolute value.
|
double |
Level1.nrm2(INDArray arr)
computes the Euclidean norm of a vector.
|
void |
Lapack.potrf(INDArray A,
boolean lower)
Triangular decomposiiton of a positive definite matrix ( cholesky )
Factorize a matrix A such that A = LL* (assuming lower==true) or
A = U*U (a * represents conjugate i.e. if matrix is real U* is a transpose)
The matrix A is overridden by the L (or U).
|
void |
Level1.rot(long N,
INDArray X,
INDArray Y,
double c,
double s)
performs rotation of points in the plane.
|
void |
Level1.rotg(INDArray a,
INDArray b,
INDArray c,
INDArray s)
computes parameters for a Givens rotation.
|
void |
Level1.rotmg(INDArray d1,
INDArray d2,
INDArray b1,
double b2,
INDArray P)
computes the modified parameters for a Givens rotation.
|
void |
Level2.sbmv(char order,
char Uplo,
double alpha,
INDArray A,
INDArray X,
double beta,
INDArray Y)
sbmv computes a matrix-vector product using a symmetric band matrix:
y := alpha*a*x + beta*y.
|
void |
Level1.scal(long N,
double alpha,
INDArray X)
computes a vector by a scalar product.
|
static void |
BlasBufferUtil.setData(double[] data,
INDArray toSet)
Set the data for the underlying array.
|
static void |
BlasBufferUtil.setData(float[] data,
INDArray toSet)
Set the data for the underlying array.
|
void |
Level2.spmv(char order,
char Uplo,
double alpha,
INDArray Ap,
INDArray X,
double beta,
INDArray Y) |
void |
Level2.spr(char order,
char Uplo,
double alpha,
INDArray X,
INDArray Ap)
spr performs a rank-1 update of an n-by-n packed symmetric matrix a:
a := alpha*x*x' + a.
|
void |
Level2.spr2(char order,
char Uplo,
double alpha,
INDArray X,
INDArray Y,
INDArray A)
?
|
void |
Level1.swap(INDArray x,
INDArray y)
swaps a vector with another vector.
|
int |
Lapack.syev(char jobz,
char uplo,
INDArray A,
INDArray V)
Caclulate the eigenvalues and vectors of a symmetric matrix.
|
void |
Level3.symm(char Order,
char Side,
char Uplo,
double alpha,
INDArray A,
INDArray B,
double beta,
INDArray C)
her2k performs a rank-2k update of an n-by-n Hermitian matrix c, that is, one of the following operations:
c := alpha*a*conjg(b') + conjg(alpha)*b*conjg(a') + beta*c, for trans = 'N'or'n'
c := alpha*conjg(b')*a + conjg(alpha)*conjg(a')*b + beta*c, for trans = 'C'or'c'
where c is an n-by-n Hermitian matrix;
a and b are n-by-k matrices if trans = 'N'or'n',
a and b are k-by-n matrices if trans = 'C'or'c'.
|
void |
Level2.symv(char order,
char Uplo,
double alpha,
INDArray A,
INDArray X,
double beta,
INDArray Y)
symv computes a matrix-vector product for a symmetric matrix:
y := alpha*a*x + beta*y.
|
void |
Level2.syr(char order,
char Uplo,
int N,
double alpha,
INDArray X,
INDArray A)
syr performs a rank-1 update of an n-by-n symmetric matrix a:
a := alpha*x*x' + a.
|
void |
Level2.syr2(char order,
char Uplo,
double alpha,
INDArray X,
INDArray Y,
INDArray A) |
void |
Level3.syr2k(char Order,
char Uplo,
char Trans,
double alpha,
INDArray A,
INDArray B,
double beta,
INDArray C)
yr2k performs a rank-2k update of an n-by-n symmetric matrix c, that is, one of the following operations:
c := alpha*a*b' + alpha*b*a' + beta*c for trans = 'N'or'n'
c := alpha*a'*b + alpha*b'*a + beta*c for trans = 'T'or't',
where c is an n-by-n symmetric matrix;
a and b are n-by-k matrices, if trans = 'N'or'n',
a and b are k-by-n matrices, if trans = 'T'or't'.
|
void |
Level3.syrk(char Order,
char Uplo,
char Trans,
double alpha,
INDArray A,
double beta,
INDArray C)
syrk performs a rank-n update of an n-by-n symmetric matrix c, that is, one of the following operations:
c := alpha*a*a' + beta*c for trans = 'N'or'n'
c := alpha*a'*a + beta*c for trans = 'T'or't','C'or'c',
where c is an n-by-n symmetric matrix;
a is an n-by-k matrix, if trans = 'N'or'n',
a is a k-by-n matrix, if trans = 'T'or't','C'or'c'.
|
void |
Level2.tbmv(char order,
char Uplo,
char TransA,
char Diag,
INDArray A,
INDArray X)
syr2 performs a rank-2 update of an n-by-n symmetric matrix a:
a := alpha*x*y' + alpha*y*x' + a.
|
void |
Level2.tbsv(char order,
char Uplo,
char TransA,
char Diag,
INDArray A,
INDArray X)
?
|
void |
Level2.tpmv(char order,
char Uplo,
char TransA,
char Diag,
INDArray Ap,
INDArray X)
tpmv computes a matrix-vector product using a triangular packed matrix.
|
void |
Level2.tpsv(char order,
char Uplo,
char TransA,
char Diag,
INDArray Ap,
INDArray X)
tpsv solves a system of linear equations whose coefficients are in a triangular packed matrix.
|
void |
Level3.trmm(char Order,
char Side,
char Uplo,
char TransA,
char Diag,
double alpha,
INDArray A,
INDArray B,
INDArray C)
syr2k performs a rank-2k update of an n-by-n symmetric matrix c, that is, one of the following operations:
c := alpha*a*b' + alpha*b*a' + beta*c for trans = 'N'or'n'
c := alpha*a'*b + alpha*b'*a + beta*c for trans = 'T'or't',
where c is an n-by-n symmetric matrix;
a and b are n-by-k matrices, if trans = 'N'or'n',
a and b are k-by-n matrices, if trans = 'T'or't'.
|
void |
Level2.trmv(char order,
char Uplo,
char TransA,
char Diag,
INDArray A,
INDArray X)
trmv computes a matrix-vector product using a triangular matrix.
|
void |
Level3.trsm(char Order,
char Side,
char Uplo,
char TransA,
char Diag,
double alpha,
INDArray A,
INDArray B)
?
|
void |
Level2.trsv(char order,
char Uplo,
char TransA,
char Diag,
INDArray A,
INDArray X)
trsv solves a system of linear equations whose coefficients are in a triangular matrix.
|
| Modifier and Type | Method and Description |
|---|---|
INDArray |
BaseLapack.getLFactor(INDArray A) |
INDArray |
BaseLapack.getPFactor(int M,
INDArray ipiv) |
INDArray |
BaseLapack.getrf(INDArray A) |
INDArray |
BaseLapack.getUFactor(INDArray A) |
| Modifier and Type | Method and Description |
|---|---|
double |
BaseLevel1.asum(INDArray arr)
computes the sum of magnitudes of all vector elements or, for a complex vector x, the sum
|
void |
BaseLevel1.axpy(long n,
double alpha,
INDArray x,
INDArray y)
computes a vector-scalar product and adds the result to a vector.
|
void |
BaseLevel1.copy(INDArray x,
INDArray y)
swaps a vector with another vector.
|
protected abstract double |
BaseLevel1.dasum(long N,
INDArray X,
int incX) |
protected abstract void |
BaseLevel1.daxpy(long N,
double alpha,
INDArray X,
int incX,
INDArray Y,
int incY) |
protected abstract void |
BaseLevel1.dcopy(long N,
INDArray X,
int incX,
INDArray Y,
int incY) |
protected abstract double |
BaseLevel1.ddot(long N,
INDArray X,
int incX,
INDArray Y,
int incY) |
protected abstract void |
BaseLevel2.dgbmv(char order,
char TransA,
int M,
int N,
int KL,
int KU,
double alpha,
INDArray A,
int lda,
INDArray X,
int incX,
double beta,
INDArray Y,
int incY) |
protected abstract void |
BaseLevel3.dgemm(char Order,
char TransA,
char TransB,
int M,
int N,
int K,
double alpha,
INDArray A,
int lda,
INDArray B,
int ldb,
double beta,
INDArray C,
int ldc) |
protected abstract void |
BaseLevel2.dgemv(char order,
char TransA,
int M,
int N,
double alpha,
INDArray A,
int lda,
INDArray X,
int incX,
double beta,
INDArray Y,
int incY) |
abstract void |
BaseLapack.dgeqrf(int M,
int N,
INDArray A,
INDArray R,
INDArray INFO) |
protected abstract void |
BaseLevel2.dger(char order,
int M,
int N,
double alpha,
INDArray X,
int incX,
INDArray Y,
int incY,
INDArray A,
int lda) |
abstract void |
BaseLapack.dgesvd(byte jobu,
byte jobvt,
int M,
int N,
INDArray A,
INDArray S,
INDArray U,
INDArray VT,
INDArray INFO) |
abstract void |
BaseLapack.dgetrf(int M,
int N,
INDArray A,
INDArray IPIV,
INDArray INFO) |
protected abstract double |
BaseLevel1.dnrm2(long N,
INDArray X,
int incX) |
double |
BaseLevel1.dot(long n,
double alpha,
INDArray X,
INDArray Y)
computes a vector-vector dot product.
|
abstract void |
BaseLapack.dpotrf(byte uplo,
int N,
INDArray A,
INDArray INFO) |
protected abstract void |
BaseLevel1.drot(long N,
INDArray X,
int incX,
INDArray Y,
int incY,
double c,
double s) |
protected abstract void |
BaseLevel1.drotm(long N,
INDArray X,
int incX,
INDArray Y,
int incY,
INDArray P) |
protected abstract void |
BaseLevel1.drotmg(double d1,
double d2,
double b1,
double b2,
INDArray P) |
protected abstract void |
BaseLevel2.dsbmv(char order,
char Uplo,
int N,
int K,
double alpha,
INDArray A,
int lda,
INDArray X,
int incX,
double beta,
INDArray Y,
int incY) |
protected abstract void |
BaseLevel1.dscal(long N,
double alpha,
INDArray X,
int incX) |
protected abstract double |
BaseLevel1.dsdot(long N,
INDArray X,
int incX,
INDArray Y,
int incY) |
protected abstract void |
BaseLevel2.dspmv(char order,
char Uplo,
int N,
double alpha,
INDArray Ap,
INDArray X,
int incX,
double beta,
INDArray Y,
int incY) |
protected abstract void |
BaseLevel2.dspr(char order,
char Uplo,
int N,
double alpha,
INDArray X,
int incX,
INDArray Ap) |
protected abstract void |
BaseLevel2.dspr2(char order,
char Uplo,
int N,
double alpha,
INDArray X,
int incX,
INDArray Y,
int incY,
INDArray A) |
protected abstract void |
BaseLevel1.dswap(long N,
INDArray X,
int incX,
INDArray Y,
int incY) |
abstract int |
BaseLapack.dsyev(char jobz,
char uplo,
int N,
INDArray A,
INDArray R) |
protected abstract void |
BaseLevel3.dsymm(char Order,
char Side,
char Uplo,
int M,
int N,
double alpha,
INDArray A,
int lda,
INDArray B,
int ldb,
double beta,
INDArray C,
int ldc) |
protected abstract void |
BaseLevel2.dsymv(char order,
char Uplo,
int N,
double alpha,
INDArray A,
int lda,
INDArray X,
int incX,
double beta,
INDArray Y,
int incY) |
protected abstract void |
BaseLevel2.dsyr(char order,
char Uplo,
int N,
double alpha,
INDArray X,
int incX,
INDArray A,
int lda) |
protected abstract void |
BaseLevel2.dsyr2(char order,
char Uplo,
int N,
double alpha,
INDArray X,
int incX,
INDArray Y,
int incY,
INDArray A,
int lda) |
protected abstract void |
BaseLevel3.dsyr2k(char Order,
char Uplo,
char Trans,
int N,
int K,
double alpha,
INDArray A,
int lda,
INDArray B,
int ldb,
double beta,
INDArray C,
int ldc) |
protected abstract void |
BaseLevel3.dsyrk(char Order,
char Uplo,
char Trans,
int N,
int K,
double alpha,
INDArray A,
int lda,
double beta,
INDArray C,
int ldc) |
protected abstract void |
BaseLevel2.dtbmv(char order,
char Uplo,
char TransA,
char Diag,
int N,
int K,
INDArray A,
int lda,
INDArray X,
int incX) |
protected abstract void |
BaseLevel2.dtbsv(char order,
char Uplo,
char TransA,
char Diag,
int N,
int K,
INDArray A,
int lda,
INDArray X,
int incX) |
protected abstract void |
BaseLevel2.dtpmv(char order,
char Uplo,
char TransA,
char Diag,
int N,
INDArray Ap,
INDArray X,
int incX) |
protected abstract void |
BaseLevel2.dtpsv(char order,
char Uplo,
char TransA,
char Diag,
int N,
INDArray Ap,
INDArray X,
int incX) |
protected abstract void |
BaseLevel3.dtrmm(char Order,
char Side,
char Uplo,
char TransA,
char Diag,
int M,
int N,
double alpha,
INDArray A,
int lda,
INDArray B,
int ldb) |
protected abstract void |
BaseLevel2.dtrmv(char order,
char Uplo,
char TransA,
char Diag,
int N,
INDArray A,
int lda,
INDArray X,
int incX) |
protected abstract void |
BaseLevel3.dtrsm(char Order,
char Side,
char Uplo,
char TransA,
char Diag,
int M,
int N,
double alpha,
INDArray A,
int lda,
INDArray B,
int ldb) |
protected abstract void |
BaseLevel2.dtrsv(char order,
char Uplo,
char TransA,
char Diag,
int N,
INDArray A,
int lda,
INDArray X,
int incX) |
void |
BaseLevel2.gbmv(char order,
char TransA,
int KL,
int KU,
double alpha,
INDArray A,
INDArray X,
double beta,
INDArray Y)
gbmv computes a matrix-vector product using a general band matrix and performs one of the following matrix-vector operations:
y := alpha*a*x + beta*y for trans = 'N'or'n';
y := alpha*a'*x + beta*y for trans = 'T'or't';
y := alpha*conjg(a')*x + beta*y for trans = 'C'or'c'.
|
void |
BaseLevel3.gemm(char Order,
char TransA,
char TransB,
double alpha,
INDArray A,
INDArray B,
double beta,
INDArray C)
gemm performs a matrix-matrix operation
c := alpha*op(a)*op(b) + beta*c,
where c is an m-by-n matrix,
op(a) is an m-by-k matrix,
op(b) is a k-by-n matrix.
|
void |
BaseLevel3.gemm(INDArray A,
INDArray B,
INDArray C,
boolean transposeA,
boolean transposeB,
double alpha,
double beta)
A convenience method for matrix-matrix operations with transposes.
|
void |
BaseLevel2.gemv(char order,
char transA,
double alpha,
INDArray A,
INDArray X,
double beta,
INDArray Y)
gemv computes a matrix-vector product using a general matrix and performs one of the following matrix-vector operations:
y := alpha*a*x + beta*y for trans = 'N'or'n';
y := alpha*a'*x + beta*y for trans = 'T'or't';
y := alpha*conjg(a')*x + beta*y for trans = 'C'or'c'.
|
void |
BaseLapack.geqrf(INDArray A,
INDArray R) |
void |
BaseLevel2.ger(char order,
double alpha,
INDArray X,
INDArray Y,
INDArray A)
performs a rank-1 update of a general m-by-n matrix a:
a := alpha*x*y' + a.
|
void |
BaseLapack.gesvd(INDArray A,
INDArray S,
INDArray U,
INDArray VT) |
INDArray |
BaseLapack.getLFactor(INDArray A) |
INDArray |
BaseLapack.getPFactor(int M,
INDArray ipiv) |
INDArray |
BaseLapack.getrf(INDArray A) |
INDArray |
BaseLapack.getUFactor(INDArray A) |
protected abstract float |
BaseLevel1.hasum(long N,
INDArray X,
int incX) |
protected abstract void |
BaseLevel1.haxpy(long N,
float alpha,
INDArray X,
int incX,
INDArray Y,
int incY) |
protected abstract float |
BaseLevel1.hdot(long N,
INDArray X,
int incX,
INDArray Y,
int incY) |
protected abstract void |
BaseLevel3.hgemm(char Order,
char TransA,
char TransB,
int M,
int N,
int K,
float alpha,
INDArray A,
int lda,
INDArray B,
int ldb,
float beta,
INDArray C,
int ldc) |
int |
BaseLevel1.iamax(INDArray arr)
finds the element of a
vector that has the largest absolute value.
|
int |
BaseLevel1.iamax(long n,
INDArray arr,
int stride) |
int |
BaseLevel1.iamin(INDArray arr)
finds the element of a vector that has the minimum absolute value.
|
protected abstract int |
BaseLevel1.idamax(long N,
INDArray X,
int incX) |
protected abstract int |
BaseLevel1.isamax(long N,
INDArray X,
int incX) |
double |
BaseLevel1.nrm2(INDArray arr)
computes the Euclidean norm of a vector.
|
void |
BaseLapack.potrf(INDArray A,
boolean lower) |
void |
BaseLevel1.rot(long N,
INDArray X,
INDArray Y,
double c,
double s)
performs rotation of points in the plane.
|
void |
BaseLevel1.rotg(INDArray a,
INDArray b,
INDArray c,
INDArray s)
computes parameters for a Givens rotation.
|
void |
BaseLevel1.rotmg(INDArray d1,
INDArray d2,
INDArray b1,
double b2,
INDArray P)
computes the modified parameters for a Givens rotation.
|
protected abstract float |
BaseLevel1.sasum(long N,
INDArray X,
int incX) |
protected abstract void |
BaseLevel1.saxpy(long N,
float alpha,
INDArray X,
int incX,
INDArray Y,
int incY) |
void |
BaseLevel2.sbmv(char order,
char Uplo,
double alpha,
INDArray A,
INDArray X,
double beta,
INDArray Y)
sbmv computes a matrix-vector product using a symmetric band matrix:
y := alpha*a*x + beta*y.
|
void |
BaseLevel1.scal(long N,
double alpha,
INDArray X)
computes a vector by a scalar product.
|
protected abstract void |
BaseLevel1.scopy(long N,
INDArray X,
int incX,
INDArray Y,
int incY) |
protected abstract float |
BaseLevel1.sdot(long N,
INDArray X,
int incX,
INDArray Y,
int incY) |
protected abstract float |
BaseLevel1.sdsdot(long N,
float alpha,
INDArray X,
int incX,
INDArray Y,
int incY) |
protected abstract void |
BaseLevel2.sgbmv(char order,
char TransA,
int M,
int N,
int KL,
int KU,
float alpha,
INDArray A,
int lda,
INDArray X,
int incX,
float beta,
INDArray Y,
int incY) |
protected abstract void |
BaseLevel3.sgemm(char Order,
char TransA,
char TransB,
int M,
int N,
int K,
float alpha,
INDArray A,
int lda,
INDArray B,
int ldb,
float beta,
INDArray C,
int ldc) |
protected abstract void |
BaseLevel2.sgemv(char order,
char TransA,
int M,
int N,
float alpha,
INDArray A,
int lda,
INDArray X,
int incX,
float beta,
INDArray Y,
int incY) |
abstract void |
BaseLapack.sgeqrf(int M,
int N,
INDArray A,
INDArray R,
INDArray INFO)
Float/Double versions of QR decomp.
|
protected abstract void |
BaseLevel2.sger(char order,
int M,
int N,
float alpha,
INDArray X,
int incX,
INDArray Y,
int incY,
INDArray A,
int lda) |
abstract void |
BaseLapack.sgesvd(byte jobu,
byte jobvt,
int M,
int N,
INDArray A,
INDArray S,
INDArray U,
INDArray VT,
INDArray INFO) |
abstract void |
BaseLapack.sgetrf(int M,
int N,
INDArray A,
INDArray IPIV,
INDArray INFO)
Float/Double versions of LU decomp.
|
protected abstract float |
BaseLevel1.snrm2(long N,
INDArray X,
int incX) |
void |
BaseLevel2.spmv(char order,
char Uplo,
double alpha,
INDArray Ap,
INDArray X,
double beta,
INDArray Y) |
abstract void |
BaseLapack.spotrf(byte uplo,
int N,
INDArray A,
INDArray INFO)
Float/Double versions of cholesky decomp for positive definite matrices
A = LL*
|
void |
BaseLevel2.spr(char order,
char Uplo,
double alpha,
INDArray X,
INDArray Ap)
spr performs a rank-1 update of an n-by-n packed symmetric matrix a:
a := alpha*x*x' + a.
|
void |
BaseLevel2.spr2(char order,
char Uplo,
double alpha,
INDArray X,
INDArray Y,
INDArray A)
?
|
protected abstract void |
BaseLevel1.srot(long N,
INDArray X,
int incX,
INDArray Y,
int incY,
float c,
float s) |
protected abstract void |
BaseLevel1.srotm(long N,
INDArray X,
int incX,
INDArray Y,
int incY,
INDArray P) |
protected abstract void |
BaseLevel1.srotmg(float d1,
float d2,
float b1,
float b2,
INDArray P) |
protected abstract void |
BaseLevel2.ssbmv(char order,
char Uplo,
int N,
int K,
float alpha,
INDArray A,
int lda,
INDArray X,
int incX,
float beta,
INDArray Y,
int incY) |
protected abstract void |
BaseLevel1.sscal(long N,
float alpha,
INDArray X,
int incX) |
protected abstract void |
BaseLevel2.sspmv(char order,
char Uplo,
int N,
float alpha,
INDArray Ap,
INDArray X,
int incX,
float beta,
INDArray Y,
int incY) |
protected abstract void |
BaseLevel2.sspr(char order,
char Uplo,
int N,
float alpha,
INDArray X,
int incX,
INDArray Ap) |
protected abstract void |
BaseLevel2.sspr2(char order,
char Uplo,
int N,
float alpha,
INDArray X,
int incX,
INDArray Y,
int incY,
INDArray A) |
protected abstract void |
BaseLevel1.sswap(long N,
INDArray X,
int incX,
INDArray Y,
int incY) |
abstract int |
BaseLapack.ssyev(char jobz,
char uplo,
int N,
INDArray A,
INDArray R)
Float/Double versions of eigen value/vector calc.
|
protected abstract void |
BaseLevel3.ssymm(char Order,
char Side,
char Uplo,
int M,
int N,
float alpha,
INDArray A,
int lda,
INDArray B,
int ldb,
float beta,
INDArray C,
int ldc) |
protected abstract void |
BaseLevel2.ssymv(char order,
char Uplo,
int N,
float alpha,
INDArray A,
int lda,
INDArray X,
int incX,
float beta,
INDArray Y,
int incY) |
protected abstract void |
BaseLevel2.ssyr(char order,
char Uplo,
int N,
float alpha,
INDArray X,
int incX,
INDArray A,
int lda) |
protected abstract void |
BaseLevel2.ssyr2(char order,
char Uplo,
int N,
float alpha,
INDArray X,
int incX,
INDArray Y,
int incY,
INDArray A,
int lda) |
protected abstract void |
BaseLevel3.ssyr2k(char Order,
char Uplo,
char Trans,
int N,
int K,
float alpha,
INDArray A,
int lda,
INDArray B,
int ldb,
float beta,
INDArray C,
int ldc) |
protected abstract void |
BaseLevel3.ssyrk(char Order,
char Uplo,
char Trans,
int N,
int K,
float alpha,
INDArray A,
int lda,
float beta,
INDArray C,
int ldc) |
protected abstract void |
BaseLevel2.stbmv(char order,
char Uplo,
char TransA,
char Diag,
int N,
int K,
INDArray A,
int lda,
INDArray X,
int incX) |
protected abstract void |
BaseLevel2.stbsv(char order,
char Uplo,
char TransA,
char Diag,
int N,
int K,
INDArray A,
int lda,
INDArray X,
int incX) |
protected abstract void |
BaseLevel2.stpmv(char order,
char Uplo,
char TransA,
char Diag,
int N,
INDArray Ap,
INDArray X,
int incX) |
protected abstract void |
BaseLevel2.stpsv(char order,
char Uplo,
char TransA,
char Diag,
int N,
INDArray Ap,
INDArray X,
int incX) |
protected abstract void |
BaseLevel3.strmm(char Order,
char Side,
char Uplo,
char TransA,
char Diag,
int M,
int N,
float alpha,
INDArray A,
int lda,
INDArray B,
int ldb) |
protected abstract void |
BaseLevel2.strmv(char order,
char Uplo,
char TransA,
char Diag,
int N,
INDArray A,
int lda,
INDArray X,
int incX) |
protected abstract void |
BaseLevel3.strsm(char Order,
char Side,
char Uplo,
char TransA,
char Diag,
int M,
int N,
float alpha,
INDArray A,
int lda,
INDArray B,
int ldb) |
protected abstract void |
BaseLevel2.strsv(char order,
char Uplo,
char TransA,
char Diag,
int N,
INDArray A,
int lda,
INDArray X,
int incX) |
void |
BaseLevel1.swap(INDArray x,
INDArray y)
swaps a vector with another vector.
|
int |
BaseLapack.syev(char jobz,
char uplo,
INDArray A,
INDArray V) |
void |
BaseLevel3.symm(char Order,
char Side,
char Uplo,
double alpha,
INDArray A,
INDArray B,
double beta,
INDArray C)
her2k performs a rank-2k update of an n-by-n Hermitian matrix c, that is, one of the following operations:
c := alpha*a*conjg(b') + conjg(alpha)*b*conjg(a') + beta*c, for trans = 'N'or'n'
c := alpha*conjg(b')*a + conjg(alpha)*conjg(a')*b + beta*c, for trans = 'C'or'c'
where c is an n-by-n Hermitian matrix;
a and b are n-by-k matrices if trans = 'N'or'n',
a and b are k-by-n matrices if trans = 'C'or'c'.
|
void |
BaseLevel2.symv(char order,
char Uplo,
double alpha,
INDArray A,
INDArray X,
double beta,
INDArray Y)
symv computes a matrix-vector product for a symmetric matrix:
y := alpha*a*x + beta*y.
|
void |
BaseLevel2.syr(char order,
char Uplo,
int N,
double alpha,
INDArray X,
INDArray A)
syr performs a rank-1 update of an n-by-n symmetric matrix a:
a := alpha*x*x' + a.
|
void |
BaseLevel2.syr2(char order,
char Uplo,
double alpha,
INDArray X,
INDArray Y,
INDArray A) |
void |
BaseLevel3.syr2k(char Order,
char Uplo,
char Trans,
double alpha,
INDArray A,
INDArray B,
double beta,
INDArray C)
yr2k performs a rank-2k update of an n-by-n symmetric matrix c, that is, one of the following operations:
c := alpha*a*b' + alpha*b*a' + beta*c for trans = 'N'or'n'
c := alpha*a'*b + alpha*b'*a + beta*c for trans = 'T'or't',
where c is an n-by-n symmetric matrix;
a and b are n-by-k matrices, if trans = 'N'or'n',
a and b are k-by-n matrices, if trans = 'T'or't'.
|
void |
BaseLevel3.syrk(char Order,
char Uplo,
char Trans,
double alpha,
INDArray A,
double beta,
INDArray C)
syrk performs a rank-n update of an n-by-n symmetric matrix c, that is, one of the following operations:
c := alpha*a*a' + beta*c for trans = 'N'or'n'
c := alpha*a'*a + beta*c for trans = 'T'or't','C'or'c',
where c is an n-by-n symmetric matrix;
a is an n-by-k matrix, if trans = 'N'or'n',
a is a k-by-n matrix, if trans = 'T'or't','C'or'c'.
|
void |
BaseLevel2.tbmv(char order,
char Uplo,
char TransA,
char Diag,
INDArray A,
INDArray X)
syr2 performs a rank-2 update of an n-by-n symmetric matrix a:
a := alpha*x*y' + alpha*y*x' + a.
|
void |
BaseLevel2.tbsv(char order,
char Uplo,
char TransA,
char Diag,
INDArray A,
INDArray X)
?
|
void |
BaseLevel2.tpmv(char order,
char Uplo,
char TransA,
char Diag,
INDArray Ap,
INDArray X)
tpmv computes a matrix-vector product using a triangular packed matrix.
|
void |
BaseLevel2.tpsv(char order,
char Uplo,
char TransA,
char Diag,
INDArray Ap,
INDArray X)
tpsv solves a system of linear equations whose coefficients are in a triangular packed matrix.
|
void |
BaseLevel3.trmm(char Order,
char Side,
char Uplo,
char TransA,
char Diag,
double alpha,
INDArray A,
INDArray B,
INDArray C)
syr2k performs a rank-2k update of an n-by-n symmetric matrix c, that is, one of the following operations:
c := alpha*a*b' + alpha*b*a' + beta*c for trans = 'N'or'n'
c := alpha*a'*b + alpha*b'*a + beta*c for trans = 'T'or't',
where c is an n-by-n symmetric matrix;
a and b are n-by-k matrices, if trans = 'N'or'n',
a and b are k-by-n matrices, if trans = 'T'or't'.
|
void |
BaseLevel2.trmv(char order,
char Uplo,
char TransA,
char Diag,
INDArray A,
INDArray X)
trmv computes a matrix-vector product using a triangular matrix.
|
void |
BaseLevel3.trsm(char Order,
char Side,
char Uplo,
char TransA,
char Diag,
double alpha,
INDArray A,
INDArray B)
?
|
void |
BaseLevel2.trsv(char order,
char Uplo,
char TransA,
char Diag,
INDArray A,
INDArray X)
trsv solves a system of linear equations whose coefficients are in a triangular matrix.
|
| Modifier and Type | Method and Description |
|---|---|
INDArray |
MMulTranspose.exec(INDArray a,
INDArray b,
INDArray result)
Execute the matrix multiplication: A x B
Note that if a or b have transposeA/B == true, then this is done internally.
|
| Modifier and Type | Method and Description |
|---|---|
INDArray |
MMulTranspose.exec(INDArray a,
INDArray b,
INDArray result)
Execute the matrix multiplication: A x B
Note that if a or b have transposeA/B == true, then this is done internally.
|
| Constructor and Description |
|---|
GemmParams(INDArray a,
INDArray b,
INDArray c) |
GemmParams(INDArray a,
INDArray b,
INDArray c,
boolean transposeA,
boolean transposeB) |
GemvParameters(INDArray a,
INDArray x,
INDArray y) |
| Modifier and Type | Method and Description |
|---|---|
INDArray |
DistributedINDArray.entry()
This method returns INDArray for the current device
PLEASE NOTE: if you use more than one thread per device you'd better not use this method unless you're 100% sure
|
INDArray |
DistributedINDArray.entry(int entry)
This method returns INDArray for specific entry (i.e. for specific device, if you put entries that way)
|
INDArray |
BasicAffinityManager.replicateToDevice(Integer deviceId,
INDArray array)
This method replicates given INDArray, and places it to target device.
|
INDArray |
AffinityManager.replicateToDevice(Integer deviceId,
INDArray array)
This method replicates given INDArray, and places it to target device.
|
| Modifier and Type | Method and Description |
|---|---|
void |
BasicAffinityManager.ensureLocation(INDArray array,
AffinityManager.Location location) |
void |
AffinityManager.ensureLocation(INDArray array,
AffinityManager.Location location)
This method propagates given INDArray to specified location
|
AffinityManager.Location |
BasicAffinityManager.getActiveLocation(INDArray array) |
AffinityManager.Location |
AffinityManager.getActiveLocation(INDArray array)
This method returns last-updated location for the given INDArray
|
Integer |
BasicAffinityManager.getDeviceForArray(INDArray array) |
Integer |
AffinityManager.getDeviceForArray(INDArray array)
This method returns id of current device for a given INDArray
|
void |
DistributedINDArray.propagate(INDArray array)
This method propagates given INDArray to all entries as is
|
INDArray |
BasicAffinityManager.replicateToDevice(Integer deviceId,
INDArray array)
This method replicates given INDArray, and places it to target device.
|
INDArray |
AffinityManager.replicateToDevice(Integer deviceId,
INDArray array)
This method replicates given INDArray, and places it to target device.
|
void |
BasicAffinityManager.tagLocation(INDArray array,
AffinityManager.Location location) |
void |
AffinityManager.tagLocation(INDArray array,
AffinityManager.Location location)
This method tags specific INDArray as "recent" on specified location
|
void |
AffinityManager.touch(INDArray array)
Utility method, to associate INDArray with specific device (backend-specific)
|
| Constructor and Description |
|---|
FirstAxisIterator(INDArray iterateOver) |
INDArrayIterator(INDArray iterateOver) |
| Modifier and Type | Class and Description |
|---|---|
class |
BaseNDArray
NDArray: (think numpy)
A few things of note.
|
| Modifier and Type | Method and Description |
|---|---|
INDArray |
INDArray.add(INDArray other)
Element-wise copy addition of two NDArrays
|
INDArray |
BaseNDArray.add(INDArray other) |
INDArray |
INDArray.add(INDArray other,
INDArray result)
Element-wise copy addition of two NDArrays
|
INDArray |
BaseNDArray.add(INDArray other,
INDArray result) |
INDArray |
INDArray.add(Number n)
Scalar addition (cloning)
|
INDArray |
BaseNDArray.add(Number n) |
INDArray |
INDArray.add(Number n,
INDArray result)
Addition of this ndarray.
|
INDArray |
BaseNDArray.add(Number n,
INDArray result) |
INDArray |
INDArray.addColumnVector(INDArray columnVector)
Addition of a column vector (copy)
|
INDArray |
BaseNDArray.addColumnVector(INDArray columnVector) |
INDArray |
INDArray.addi(INDArray other)
in place (element wise) addition of two NDArrays
|
INDArray |
BaseNDArray.addi(INDArray other) |
INDArray |
INDArray.addi(INDArray other,
INDArray result)
in place (element wise) addition of two NDArrays
|
INDArray |
BaseNDArray.addi(INDArray other,
INDArray result) |
INDArray |
INDArray.addi(Number n)
In place scalar addition
|
INDArray |
BaseNDArray.addi(Number n) |
INDArray |
INDArray.addi(Number n,
INDArray result)
In place addition
|
INDArray |
BaseNDArray.addi(Number n,
INDArray result) |
INDArray |
INDArray.addiColumnVector(INDArray columnVector)
In place addition of a column vector
|
INDArray |
BaseNDArray.addiColumnVector(INDArray columnVector) |
INDArray |
INDArray.addiRowVector(INDArray rowVector)
In place addition of a row vector
|
INDArray |
BaseNDArray.addiRowVector(INDArray rowVector) |
INDArray |
INDArray.addRowVector(INDArray rowVector)
Addition of a row vector (copy)
|
INDArray |
BaseNDArray.addRowVector(INDArray rowVector) |
INDArray |
INDArray.amax(int... dimension)
Returns the absolute overall max of this ndarray along given dimensions
|
INDArray |
BaseNDArray.amax(int... dimension) |
INDArray |
INDArray.amean(int... dimension)
Returns the absolute overall mean of this ndarray
|
INDArray |
BaseNDArray.amean(int... dimension) |
INDArray |
INDArray.amin(int... dimension)
Returns minimum (absolute) value in this INDArray, along the specified dimensions
|
INDArray |
BaseNDArray.amin(int... dimension) |
INDArray |
INDArray.argMax(int... dimension)
This method returns index of highest value along specified dimension(s)
|
INDArray |
BaseNDArray.argMax(int... dimension) |
INDArray |
INDArray.assign(boolean value)
Set all entries of the ndarray to the specified value
|
INDArray |
BaseNDArray.assign(boolean value) |
INDArray |
INDArray.assign(INDArray arr)
Assign all of the elements in the given ndarray to this ndarray
|
INDArray |
BaseNDArray.assign(INDArray arr) |
INDArray |
INDArray.assign(Number value)
Set all entries of the ndarray to the specified value
|
INDArray |
BaseNDArray.assign(Number value) |
INDArray |
INDArray.assignIf(INDArray arr,
Condition condition)
Assign all elements from given ndarray that are matching given condition,
ndarray to this ndarray
|
INDArray |
BaseNDArray.assignIf(INDArray arr,
Condition condition) |
INDArray |
INDArray.broadcast(INDArray result)
Broadcasts this ndarray to be the specified shape
|
INDArray |
BaseNDArray.broadcast(INDArray result) |
INDArray |
INDArray.broadcast(long... shape)
Broadcasts this ndarray to be the specified shape
|
INDArray |
BaseNDArray.broadcast(long... shape) |
INDArray |
INDArray.castTo(DataType dataType)
This method cast elements of this INDArray to new data type
|
INDArray |
BaseNDArray.castTo(DataType dataType) |
INDArray |
INDArray.cond(Condition condition)
Returns a binary INDArray with value 'true' if the element matches the specified condition and 'false' otherwise
|
INDArray |
BaseNDArray.cond(Condition condition) |
protected INDArray |
BaseNDArray.create(DataBuffer buffer) |
protected INDArray |
BaseNDArray.create(DataBuffer data,
int[] shape,
int[] strides) |
protected INDArray |
BaseNDArray.create(DataBuffer data,
int[] newShape,
int[] newStrides,
long offset) |
protected INDArray |
BaseNDArray.create(DataBuffer data,
int[] newShape,
int[] newStrides,
long offset,
char ordering) |
protected INDArray |
BaseNDArray.create(DataBuffer data,
int[] shape,
long offset) |
protected INDArray |
BaseNDArray.create(DataBuffer data,
long[] newShape,
long[] newStrides,
long offset,
char ordering) |
protected INDArray |
BaseNDArray.create(int[] shape) |
protected INDArray |
BaseNDArray.create(int[] shape,
char ordering) |
protected INDArray |
BaseNDArray.create(int[] shape,
int[] strides,
long offset) |
protected INDArray |
BaseNDArray.create(int rows,
int length) |
protected INDArray |
BaseNDArray.createScalar(double d) |
protected INDArray |
BaseNDArray.createScalarForIndex(long i,
boolean applyOffset) |
INDArray |
INDArray.cumsum(int dimension)
Returns the cumulative sum along a dimension.
|
INDArray |
BaseNDArray.cumsum(int dimension) |
INDArray |
INDArray.cumsumi(int dimension)
Returns the cumulative sum along a dimension.
|
INDArray |
BaseNDArray.cumsumi(int dimension) |
INDArray |
INDArray.detach()
This method detaches INDArray from Workspace, returning copy.
|
INDArray |
BaseNDArray.detach() |
INDArray |
INDArray.dimShuffle(Object[] rearrange,
int[] newOrder,
boolean[] broadCastable)
Dimshuffle: an extension of permute that adds the ability
to broadcast various dimensions.
|
INDArray |
BaseNDArray.dimShuffle(Object[] rearrange,
int[] newOrder,
boolean[] broadCastable)
Deprecated.
|
INDArray |
INDArray.dimShuffle(Object[] rearrange,
long[] newOrder,
boolean[] broadCastable)
See {@link #dimShuffle(Object[], int[], boolean[])
|
INDArray |
BaseNDArray.dimShuffle(Object[] rearrange,
long[] newOrder,
boolean[] broadCastable)
Dimshuffle: an extension of permute that adds the ability
to broadcast various dimensions.
|
INDArray |
INDArray.div(INDArray other)
Copy (element wise) division of two NDArrays
|
INDArray |
BaseNDArray.div(INDArray other) |
INDArray |
INDArray.div(INDArray other,
INDArray result)
copy (element wise) division of two NDArrays
|
INDArray |
BaseNDArray.div(INDArray other,
INDArray result) |
INDArray |
INDArray.div(Number n)
Division by a number
|
INDArray |
BaseNDArray.div(Number n) |
INDArray |
INDArray.div(Number n,
INDArray result)
Division if ndarray by number
|
INDArray |
BaseNDArray.div(Number n,
INDArray result) |
INDArray |
INDArray.divColumnVector(INDArray columnVector)
Division of a column vector (copy)
|
INDArray |
BaseNDArray.divColumnVector(INDArray columnVector) |
INDArray |
INDArray.divi(INDArray other)
in place (element wise) division of two NDArrays
|
INDArray |
BaseNDArray.divi(INDArray other) |
INDArray |
INDArray.divi(INDArray other,
INDArray result)
in place (element wise) division of two NDArrays
|
INDArray |
BaseNDArray.divi(INDArray other,
INDArray result) |
INDArray |
INDArray.divi(Number n)
In place scalar division
|
INDArray |
BaseNDArray.divi(Number n) |
INDArray |
INDArray.divi(Number n,
INDArray result)
In place division of this ndarray
|
INDArray |
BaseNDArray.divi(Number n,
INDArray result) |
INDArray |
INDArray.diviColumnVector(INDArray columnVector)
In place division of a column vector
|
INDArray |
BaseNDArray.diviColumnVector(INDArray columnVector) |
INDArray |
INDArray.diviRowVector(INDArray rowVector)
In place division of a row vector
|
INDArray |
BaseNDArray.diviRowVector(INDArray rowVector) |
INDArray |
INDArray.divRowVector(INDArray rowVector)
Division of a row vector (copy)
|
INDArray |
BaseNDArray.divRowVector(INDArray rowVector) |
protected INDArray |
BaseNDArray.doColumnWise(INDArray columnVector,
char operation)
Do a row wise op (a,s,m,d)
a : add
s : subtract
m : multiply
d : divide
h : reverse subtraction
t : reverse division
|
protected INDArray |
BaseNDArray.doRowWise(INDArray rowVector,
char operation)
Do a row wise op (a,s,m,d)
a : add
s : subtract
m : multiply
d : divide
h : reverse subtraction
t : reverse division
|
INDArray |
INDArray.dup()
Returns a copy of this ndarray
|
INDArray |
BaseNDArray.dup() |
INDArray |
INDArray.dup(char order)
Returns a copy of this ndarray, where the returned ndarray has the specified order
|
INDArray |
BaseNDArray.dup(char order) |
INDArray |
INDArray.entropy(int... dimension)
Returns entropy value for this INDArray along specified dimension(s)
|
INDArray |
BaseNDArray.entropy(int... dimension) |
INDArray |
INDArray.eps(INDArray other)
Returns the binary ndarray for "Epsilon equals" comparison.
|
INDArray |
BaseNDArray.eps(INDArray other) |
INDArray |
INDArray.eps(Number other)
Returns the binary ndarray for "Epsilon equals" comparison.
|
INDArray |
BaseNDArray.eps(Number other) |
INDArray |
INDArray.eq(INDArray other)
Returns the binary ndarray for "Equals" comparison.
|
INDArray |
BaseNDArray.eq(INDArray other) |
INDArray |
INDArray.eq(Number other)
Returns the binary ndarray for "Equals" comparison.
|
INDArray |
BaseNDArray.eq(Number other) |
INDArray |
INDArray.fmod(INDArray denominator)
remainder of division
|
INDArray |
BaseNDArray.fmod(INDArray denominator) |
INDArray |
INDArray.fmod(INDArray denominator,
INDArray result)
remainder of division
|
INDArray |
BaseNDArray.fmod(INDArray denominator,
INDArray result) |
INDArray |
INDArray.fmod(Number denominator)
remainder of division by scalar.
|
INDArray |
BaseNDArray.fmod(Number denominator) |
INDArray |
INDArray.fmod(Number denominator,
INDArray result)
remainder of division by scalar.
|
INDArray |
BaseNDArray.fmod(Number denominator,
INDArray result) |
INDArray |
INDArray.fmodi(INDArray denominator)
In place fmod
|
INDArray |
BaseNDArray.fmodi(INDArray denominator) |
INDArray |
INDArray.fmodi(Number denominator)
In place fmod
|
INDArray |
BaseNDArray.fmodi(Number denominator) |
INDArray |
INDArray.get(INDArray indices)
Get the elements from this ndarray based on the specified indices
|
INDArray |
BaseNDArray.get(INDArray indices) |
INDArray |
INDArray.get(INDArrayIndex... indexes)
Returns a subset of this array based on the specified indexes
|
INDArray |
BaseNDArray.get(INDArrayIndex... indexes) |
INDArray |
INDArray.getColumn(long i)
Returns the specified column.
|
INDArray |
BaseNDArray.getColumn(long c) |
INDArray |
INDArray.getColumn(long i,
boolean keepDim)
Returns the specified column.
|
INDArray |
BaseNDArray.getColumn(long c,
boolean keepDim) |
INDArray |
INDArray.getColumns(int... columns)
Get an INDArray comprised of the specified columns only.
|
INDArray |
BaseNDArray.getColumns(int... cindices) |
INDArray |
INDArray.getRow(long i)
Returns the specified row as a 1D vector.
|
INDArray |
BaseNDArray.getRow(long r) |
INDArray |
INDArray.getRow(long i,
boolean keepDim)
Returns the specified row.
|
INDArray |
BaseNDArray.getRow(long r,
boolean keepDim) |
INDArray |
INDArray.getRows(int... rows)
Get an INDArray comprised of the specified rows only.
|
INDArray |
BaseNDArray.getRows(int[] rindices) |
INDArray |
INDArray.getScalar(int... indices)
Returns the elements at the specified indices
|
INDArray |
BaseNDArray.getScalar(int[] indexes) |
INDArray |
INDArray.getScalar(long... indices)
See
getScalar(int[]) |
INDArray |
BaseNDArray.getScalar(long... indexes) |
INDArray |
INDArray.getScalar(long i)
Returns the element at the specified index
|
INDArray |
BaseNDArray.getScalar(long i) |
INDArray |
INDArray.getScalar(long row,
long column)
Returns the element at the specified row/column
|
INDArray |
BaseNDArray.getScalar(long row,
long column) |
INDArray |
INDArray.getWhere(INDArray comp,
Condition condition)
Boolean indexing:
Return the element if it fulfills the condition in
result array
|
INDArray |
BaseNDArray.getWhere(INDArray comp,
Condition condition) |
INDArray |
INDArray.getWhere(Number comp,
Condition condition)
Boolean indexing:
Return the element if it fulfills the condition in
result array
|
INDArray |
BaseNDArray.getWhere(Number comp,
Condition condition) |
INDArray |
INDArray.gt(INDArray other)
Returns the binary ndarray for "Greater Than" comparison.
|
INDArray |
BaseNDArray.gt(INDArray other) |
INDArray |
INDArray.gt(Number other)
Returns the binary ndarray for "Greater" comparison.
|
INDArray |
BaseNDArray.gt(Number other) |
INDArray |
INDArray.gte(Number other)
Returns binary ndarray for "Greter or equals" comparison.
|
INDArray |
BaseNDArray.gte(Number other) |
INDArray |
INDArray.isInfinite()
Returns the binary NDArray with value true where this array's entries are infinite, or false where they
are not infinite
|
INDArray |
BaseNDArray.isInfinite() |
INDArray |
INDArray.isNaN()
Returns the binary NDArray with value true where this array's entries are NaN, or false where they
are not infinite
|
INDArray |
BaseNDArray.isNaN() |
INDArray |
INDArray.leverage()
This method detaches INDArray from current Workspace, and attaches it to Workspace above, if any.
|
INDArray |
BaseNDArray.leverage() |
INDArray |
INDArray.leverageOrDetach(String id)
This method detaches INDArray from current Workspace, and attaches it to Workspace with a given Id, if a workspace
with the given ID is open and active.
|
INDArray |
BaseNDArray.leverageOrDetach(String id) |
INDArray |
INDArray.leverageTo(String id)
This method detaches INDArray from current Workspace, and attaches it to Workspace with a given Id - if a workspace
with that ID exists.
|
INDArray |
BaseNDArray.leverageTo(String id) |
INDArray |
INDArray.leverageTo(String id,
boolean enforceExistence)
This method detaches INDArray from current Workspace, and attaches it to Workspace with a given Id.
|
INDArray |
BaseNDArray.leverageTo(String id,
boolean enforceExistence) |
INDArray |
INDArray.like()
This method returns empty array with the same dtype/order/shape as this one
|
INDArray |
BaseNDArray.like() |
INDArray |
INDArray.logEntropy(int... dimension)
Returns log entropy value for this INDArray along specified dimension(s)
|
INDArray |
BaseNDArray.logEntropy(int... dimension) |
INDArray |
INDArray.lt(INDArray other)
Returns the binary ndarray for "Less" comparison.
|
INDArray |
BaseNDArray.lt(INDArray other) |
INDArray |
INDArray.lt(Number other)
Returns the binary ndarray for "Less" comparison.
|
INDArray |
BaseNDArray.lt(Number other) |
INDArray |
INDArray.lte(Number other)
Returns the binary ndarray for "Less or equals" comparison.
|
INDArray |
BaseNDArray.lte(Number other) |
INDArray |
INDArray.match(INDArray comp,
Condition condition)
Return a mask on whether each element matches the given condition
|
INDArray |
BaseNDArray.match(INDArray comp,
Condition condition) |
INDArray |
INDArray.match(Number comp,
Condition condition)
Returns a mask
|
INDArray |
BaseNDArray.match(Number comp,
Condition condition) |
INDArray |
INDArray.max(boolean keepDims,
int... dimension)
Returns the overall max of this ndarray along given dimensions
|
INDArray |
BaseNDArray.max(boolean keepDims,
int... dimension) |
INDArray |
INDArray.max(int... dimension)
Returns the overall max of this ndarray along given dimensions
|
INDArray |
BaseNDArray.max(int... dimension) |
INDArray |
INDArray.mean(boolean keepDims,
int... dimension)
Returns the overall mean of this ndarray
|
INDArray |
BaseNDArray.mean(boolean keepDims,
int... dimension) |
INDArray |
INDArray.mean(INDArray result,
boolean keepDims,
int... dimension)
Returns the overall mean of this ndarray
|
INDArray |
BaseNDArray.mean(INDArray result,
boolean keepDims,
int... dimension) |
INDArray |
INDArray.mean(INDArray result,
int... dimension)
Returns the overall mean of this ndarray
|
INDArray |
BaseNDArray.mean(INDArray result,
int... dimension) |
INDArray |
INDArray.mean(int... dimension)
Returns the overall mean of this ndarray
|
INDArray |
BaseNDArray.mean(int... dimension) |
INDArray |
INDArray.median(int... dimension)
This method returns median along given dimension(s)
|
INDArray |
BaseNDArray.median(int... dimension) |
INDArray |
INDArray.migrate()
This method pulls this INDArray into current Workspace.
|
INDArray |
BaseNDArray.migrate() |
INDArray |
INDArray.migrate(boolean detachOnNoWs)
This method pulls this INDArray into current Workspace, or optionally detaches if no workspace is present.
|
INDArray |
BaseNDArray.migrate(boolean detachOnNoWs) |
INDArray |
INDArray.min(boolean keepDims,
int... dimension)
Returns the overall min of this ndarray
|
INDArray |
BaseNDArray.min(boolean keepDims,
int... dimension) |
INDArray |
INDArray.min(int... dimension)
Returns the overall min of this ndarray
|
INDArray |
BaseNDArray.min(int... dimension) |
INDArray |
INDArray.mmul(INDArray other)
Perform a copy matrix multiplication
|
INDArray |
BaseNDArray.mmul(INDArray other) |
INDArray |
INDArray.mmul(INDArray other,
INDArray result)
Perform an copy matrix multiplication
|
INDArray |
BaseNDArray.mmul(INDArray other,
INDArray result)
Perform an copy matrix multiplication
|
INDArray |
INDArray.mmul(INDArray other,
INDArray result,
MMulTranspose mMulTranspose)
Perform an copy matrix multiplication
|
INDArray |
BaseNDArray.mmul(INDArray other,
INDArray result,
MMulTranspose mMulTranspose) |
INDArray |
INDArray.mmul(INDArray other,
MMulTranspose mMulTranspose)
Perform a copy matrix multiplication
|
INDArray |
BaseNDArray.mmul(INDArray other,
MMulTranspose mMulTranspose) |
INDArray |
INDArray.mmuli(INDArray other)
Perform an inplace matrix multiplication
|
INDArray |
BaseNDArray.mmuli(INDArray other) |
INDArray |
INDArray.mmuli(INDArray other,
INDArray result)
Perform an inplace matrix multiplication
|
INDArray |
BaseNDArray.mmuli(INDArray other,
INDArray result) |
INDArray |
INDArray.mmuli(INDArray other,
INDArray result,
MMulTranspose transpose)
Perform an in place matrix multiplication
|
INDArray |
BaseNDArray.mmuli(INDArray other,
INDArray result,
MMulTranspose transpose) |
INDArray |
INDArray.mmuli(INDArray other,
MMulTranspose transpose)
Perform an copy matrix multiplication
|
INDArray |
BaseNDArray.mmuli(INDArray other,
MMulTranspose transpose) |
INDArray |
INDArray.mul(INDArray other)
copy (element wise) multiplication of two NDArrays
|
INDArray |
BaseNDArray.mul(INDArray other) |
INDArray |
INDArray.mul(INDArray other,
INDArray result)
copy (element wise) multiplication of two NDArrays
|
INDArray |
BaseNDArray.mul(INDArray other,
INDArray result) |
INDArray |
INDArray.mul(Number n)
Scalar multiplication (copy)
|
INDArray |
BaseNDArray.mul(Number n) |
INDArray |
INDArray.mul(Number n,
INDArray result)
Multiplication of ndarray.
|
INDArray |
BaseNDArray.mul(Number n,
INDArray result) |
INDArray |
INDArray.mulColumnVector(INDArray columnVector)
Multiplication of a column vector (copy)
|
INDArray |
BaseNDArray.mulColumnVector(INDArray columnVector) |
INDArray |
INDArray.muli(INDArray other)
in place (element wise) multiplication of two NDArrays
|
INDArray |
BaseNDArray.muli(INDArray other) |
INDArray |
INDArray.muli(INDArray other,
INDArray result)
in place (element wise) multiplication of two NDArrays
|
INDArray |
BaseNDArray.muli(INDArray other,
INDArray result) |
INDArray |
INDArray.muli(Number n)
In place scalar multiplication
|
INDArray |
BaseNDArray.muli(Number n) |
INDArray |
INDArray.muli(Number n,
INDArray result)
In place multiplication of this ndarray
|
INDArray |
BaseNDArray.muli(Number n,
INDArray result) |
INDArray |
INDArray.muliColumnVector(INDArray columnVector)
In place multiplication of a column vector
|
INDArray |
BaseNDArray.muliColumnVector(INDArray columnVector) |
INDArray |
INDArray.muliRowVector(INDArray rowVector)
In place multiplication of a row vector
|
INDArray |
BaseNDArray.muliRowVector(INDArray rowVector) |
INDArray |
INDArray.mulRowVector(INDArray rowVector)
Multiplication of a row vector (copy)
|
INDArray |
BaseNDArray.mulRowVector(INDArray rowVector) |
INDArray |
INDArray.neg()
Returns the ndarray negative (cloned)
|
INDArray |
BaseNDArray.neg() |
INDArray |
INDArray.negi()
In place setting of the negative version of this ndarray
|
INDArray |
BaseNDArray.negi() |
INDArray |
INDArray.neq(INDArray other)
Returns the binary ndarray for "Not equals" comparison.
|
INDArray |
BaseNDArray.neq(INDArray other) |
INDArray |
INDArray.neq(Number other)
Returns the binary ndarray for "Not equals" comparison.
|
INDArray |
BaseNDArray.neq(Number other) |
protected INDArray |
BaseNDArray.newShape(long[] newShape,
char ordering) |
INDArray |
INDArray.norm1(boolean keepDims,
int... dimension)
Returns the norm1 (L1 norm, i.e., sum of absolute values; also known as Taxicab or Manhattan norm) along the
specified dimension
|
INDArray |
BaseNDArray.norm1(boolean keepDims,
int... dimension) |
INDArray |
INDArray.norm1(int... dimension)
Returns the norm1 (L1 norm, i.e., sum of absolute values; also known as Taxicab or Manhattan norm) along the
specified dimension
|
INDArray |
BaseNDArray.norm1(int... dimension) |
INDArray |
INDArray.norm2(boolean keepDims,
int... dimension)
Returns the norm2 (L2 norm, sqrt(sum(x_i^2), also known as Euclidean norm) along the specified dimension(s)
|
INDArray |
BaseNDArray.norm2(boolean keepDims,
int... dimension) |
INDArray |
INDArray.norm2(int... dimension)
Returns the norm2 (L2 norm, sqrt(sum(x_i^2), also known as Euclidean norm) along the specified dimension(s)
|
INDArray |
BaseNDArray.norm2(int... dimension) |
INDArray |
INDArray.normmax(boolean keepDims,
int... dimension)
Returns the max norm (aka infinity norm, equal to the maximum absolute value) along the specified dimension(s)
|
INDArray |
BaseNDArray.normmax(boolean keepDims,
int... dimension) |
INDArray |
INDArray.normmax(int... dimension)
Returns the max norm (aka infinity norm, equal to the maximum absolute value) along the specified dimension(s)
|
INDArray |
BaseNDArray.normmax(int... dimension) |
INDArray |
INDArray.percentile(Number percentile,
int... dimension)
This method returns percentile along given dimension(s)
|
INDArray |
BaseNDArray.percentile(Number quantile,
int... dimension) |
INDArray |
INDArray.permute(int... rearrange)
See: http://www.mathworks.com/help/matlab/ref/permute.html
|
INDArray |
BaseNDArray.permute(int... rearrange) |
INDArray |
INDArray.permutei(int... rearrange)
An in-place version of permute.
|
INDArray |
BaseNDArray.permutei(int... rearrange) |
INDArray |
INDArray.prod(boolean keepDims,
int... dimension)
Returns the product along a given dimension
|
INDArray |
BaseNDArray.prod(boolean keepDims,
int... dimension) |
INDArray |
INDArray.prod(int... dimension)
Returns the product along a given dimension
|
INDArray |
BaseNDArray.prod(int... dimension) |
INDArray |
INDArray.put(INDArray indices,
INDArray element)
Put element in to the indices denoted by
the indices ndarray.
|
INDArray |
BaseNDArray.put(INDArray indices,
INDArray element) |
INDArray |
INDArray.put(INDArrayIndex[] indices,
INDArray element)
Put the elements of the ndarray in to the specified indices
|
INDArray |
BaseNDArray.put(INDArrayIndex[] indices,
INDArray element) |
INDArray |
INDArray.put(INDArrayIndex[] indices,
Number element)
Put the elements of the ndarray in to the specified indices
|
INDArray |
BaseNDArray.put(INDArrayIndex[] indices,
Number element) |
INDArray |
INDArray.put(int[] indices,
INDArray element)
Inserts the element at the specified index
|
INDArray |
BaseNDArray.put(int[] indices,
INDArray element) |
INDArray |
INDArray.put(int i,
INDArray element)
Inserts the element at the specified index
|
INDArray |
BaseNDArray.put(int i,
INDArray element) |
INDArray |
INDArray.put(int i,
int j,
INDArray element)
Inserts the element at the specified index
|
INDArray |
BaseNDArray.put(int i,
int j,
INDArray element) |
INDArray |
INDArray.put(int i,
int j,
Number element)
Inserts the element at the specified index
|
INDArray |
BaseNDArray.put(int i,
int j,
Number element) |
INDArray |
INDArray.putColumn(int column,
INDArray toPut)
Insert a column in to this array
Will throw an exception if this ndarray is not a matrix
|
INDArray |
BaseNDArray.putColumn(int column,
INDArray toPut) |
INDArray |
INDArray.putiColumnVector(INDArray columnVector)
In place assignment of a column vector
|
INDArray |
BaseNDArray.putiColumnVector(INDArray columnVector) |
INDArray |
INDArray.putiRowVector(INDArray rowVector)
in place assignment of row vector, to each row of this array
|
INDArray |
BaseNDArray.putiRowVector(INDArray rowVector) |
INDArray |
INDArray.putRow(long row,
INDArray toPut)
Insert a row in to this array
Will throw an exception if this ndarray is not a matrix
|
INDArray |
BaseNDArray.putRow(long row,
INDArray toPut) |
INDArray |
INDArray.putScalar(int[] i,
double value)
Insert the item at the specified indices
|
INDArray |
BaseNDArray.putScalar(int[] indexes,
double value) |
INDArray |
INDArray.putScalar(int[] indexes,
float value)
Put the specified float value at the specified indices in this array
|
INDArray |
BaseNDArray.putScalar(int[] indexes,
float value) |
INDArray |
INDArray.putScalar(int[] indexes,
int value)
Put the specified integer value at the specified indices in this array
|
INDArray |
BaseNDArray.putScalar(int[] indexes,
int value) |
INDArray |
INDArray.putScalar(long[] i,
double value)
|
INDArray |
BaseNDArray.putScalar(long[] indexes,
double value) |
INDArray |
INDArray.putScalar(long[] i,
float value)
|
INDArray |
BaseNDArray.putScalar(long[] indexes,
float value) |
INDArray |
INDArray.putScalar(long[] i,
int value)
|
INDArray |
BaseNDArray.putScalar(long[] indexes,
int value) |
INDArray |
INDArray.putScalar(long i,
double value)
Insert the number linearly in to the ndarray
|
INDArray |
BaseNDArray.putScalar(long i,
double value) |
INDArray |
INDArray.putScalar(long i,
float value)
Insert a scalar float at the specified index
|
INDArray |
BaseNDArray.putScalar(long i,
float value) |
INDArray |
INDArray.putScalar(long i,
int value)
Insert a scalar int at the specified index
|
INDArray |
BaseNDArray.putScalar(long i,
int value) |
INDArray |
INDArray.putScalar(long row,
long col,
double value)
Insert the value at the specified indices, in a 2d (rank 2) NDArray
Equivalent to putScalar(int[], double) but avoids int[] creation |
INDArray |
BaseNDArray.putScalar(long row,
long col,
double value) |
INDArray |
INDArray.putScalar(long dim0,
long dim1,
long dim2,
double value)
Insert the value at the specified indices, in a 3d (rank 3) NDArray
Equivalent to putScalar(int[], double) but avoids int[] creation |
INDArray |
BaseNDArray.putScalar(long dim0,
long dim1,
long dim2,
double value) |
INDArray |
INDArray.putScalar(long dim0,
long dim1,
long dim2,
long dim3,
double value)
Insert the value at the specified indices, in a 4d (rank 4) NDArray
Equivalent to putScalar(int[], double) but avoids int[] creation |
INDArray |
BaseNDArray.putScalar(long dim0,
long dim1,
long dim2,
long dim3,
double value) |
INDArray |
INDArray.putScalarUnsafe(long offset,
double value)
Insert a scalar at the given linear offset
|
INDArray |
BaseNDArray.putScalarUnsafe(long offset,
double value) |
INDArray |
INDArray.putSlice(int slice,
INDArray put)
Assigns the given matrix (put) to the specified slice
|
INDArray |
BaseNDArray.putSlice(int slice,
INDArray put) |
INDArray |
INDArray.putWhere(INDArray comp,
INDArray put,
Condition condition)
Assign the element according to the comparison array
|
INDArray |
BaseNDArray.putWhere(INDArray comp,
INDArray put,
Condition condition) |
INDArray |
INDArray.putWhere(Number comp,
INDArray put,
Condition condition)
Assign the element according to the comparison array
|
INDArray |
BaseNDArray.putWhere(Number comp,
INDArray put,
Condition condition) |
INDArray |
INDArray.putWhere(Number comp,
Number put,
Condition condition)
Assign the element according to the comparison array
|
INDArray |
BaseNDArray.putWhere(Number comp,
Number put,
Condition condition) |
INDArray |
INDArray.putWhereWithMask(INDArray mask,
INDArray put)
Use a pre computed mask for assigning arrays
|
INDArray |
BaseNDArray.putWhereWithMask(INDArray mask,
INDArray put) |
INDArray |
INDArray.putWhereWithMask(INDArray mask,
Number put)
Use a pre computed mask for assigning arrays
|
INDArray |
BaseNDArray.putWhereWithMask(INDArray mask,
Number put) |
INDArray |
INDArray.ravel()
Returns a flattened version (row vector) of this ndarray
|
INDArray |
BaseNDArray.ravel() |
INDArray |
INDArray.ravel(char order)
Returns a flattened version (row vector) of this ndarray
|
INDArray |
BaseNDArray.ravel(char ordering) |
INDArray |
INDArray.rdiv(INDArray other)
Reverse division, elements wise. i.e., other / this
|
INDArray |
BaseNDArray.rdiv(INDArray other) |
INDArray |
INDArray.rdiv(INDArray other,
INDArray result)
Reverse division
|
INDArray |
BaseNDArray.rdiv(INDArray other,
INDArray result) |
INDArray |
INDArray.rdiv(Number n)
Reverse division with a scalar - i.e., (n / thisArrayValues)
|
INDArray |
BaseNDArray.rdiv(Number n) |
INDArray |
INDArray.rdiv(Number n,
INDArray result)
Reverse division (number / ndarray)
|
INDArray |
BaseNDArray.rdiv(Number n,
INDArray result) |
INDArray |
INDArray.rdivColumnVector(INDArray columnVector)
Reverse division of a column vector (copy)
|
INDArray |
BaseNDArray.rdivColumnVector(INDArray columnVector) |
INDArray |
INDArray.rdivi(INDArray other)
Reverse divsion (in place). i.e., other / this
|
INDArray |
BaseNDArray.rdivi(INDArray other) |
INDArray |
INDArray.rdivi(INDArray other,
INDArray result)
Reverse division (in-place)
|
INDArray |
BaseNDArray.rdivi(INDArray other,
INDArray result) |
INDArray |
INDArray.rdivi(Number n)
In place reverse division - i.e., (n / thisArrayValues)
|
INDArray |
BaseNDArray.rdivi(Number n) |
INDArray |
INDArray.rdivi(Number n,
INDArray result)
Reverse in place division
|
INDArray |
BaseNDArray.rdivi(Number n,
INDArray result) |
INDArray |
INDArray.rdiviColumnVector(INDArray columnVector)
In place reverse divison of a column vector
|
INDArray |
BaseNDArray.rdiviColumnVector(INDArray columnVector) |
INDArray |
INDArray.rdiviRowVector(INDArray rowVector)
In place reverse division of a column vector
|
INDArray |
BaseNDArray.rdiviRowVector(INDArray rowVector) |
INDArray |
INDArray.rdivRowVector(INDArray rowVector)
Reverse division of a column vector (copy)
|
INDArray |
BaseNDArray.rdivRowVector(INDArray rowVector) |
INDArray |
INDArray.remainder(INDArray denominator)
Remainder operator
|
INDArray |
BaseNDArray.remainder(INDArray denominator) |
INDArray |
INDArray.remainder(INDArray denominator,
INDArray result)
Remainder operator
|
INDArray |
BaseNDArray.remainder(INDArray denominator,
INDArray result) |
INDArray |
INDArray.remainder(Number denominator)
The scalar remainder
|
INDArray |
BaseNDArray.remainder(Number denominator) |
INDArray |
INDArray.remainder(Number denominator,
INDArray result)
The scalar remainder
|
INDArray |
BaseNDArray.remainder(Number denominator,
INDArray result) |
INDArray |
INDArray.remainderi(INDArray denominator)
In place remainder
|
INDArray |
BaseNDArray.remainderi(INDArray denominator) |
INDArray |
INDArray.remainderi(Number denominator)
In place remainder
|
INDArray |
BaseNDArray.remainderi(Number denominator) |
INDArray |
INDArray.repeat(int dimension,
long... repeats)
Repeat elements along a specified dimension.
|
INDArray |
BaseNDArray.repeat(int dimension,
long... repeats) |
INDArray |
INDArray.replaceWhere(INDArray arr,
Condition condition)
Replaces all elements in this ndarray that are matching give condition, with corresponding elements from given array
|
INDArray |
BaseNDArray.replaceWhere(INDArray arr,
Condition condition) |
INDArray |
INDArray.repmat(int... shape)
Deprecated.
|
INDArray |
BaseNDArray.repmat(int[] shape)
Deprecated.
|
INDArray |
INDArray.repmat(long... shape)
Replicate and tile array to fill out to the given shape
See:
https://github.com/numpy/numpy/blob/master/numpy/matlib.py#L310-L358
|
INDArray |
BaseNDArray.repmat(long[] shape) |
INDArray |
INDArray.reshape(char order,
boolean enforceView,
long... newShape)
Reshapes the ndarray (note: it's not possible to change the length of the ndarray).
|
INDArray |
BaseNDArray.reshape(char order,
boolean enforceView,
long... newShape) |
INDArray |
INDArray.reshape(char order,
int... newShape)
Reshapes the ndarray (can't change the length of the ndarray).
|
INDArray |
BaseNDArray.reshape(char order,
int... newShape)
Deprecated.
|
INDArray |
INDArray.reshape(char order,
int rows,
int columns)
Reshapes the ndarray (can't change the length of the ndarray).
|
INDArray |
BaseNDArray.reshape(char order,
int rows,
int columns) |
INDArray |
INDArray.reshape(char order,
long... newShape)
Reshapes the ndarray (can't change the length of the ndarray).
|
INDArray |
BaseNDArray.reshape(char order,
long... newShape) |
INDArray |
INDArray.reshape(int[] shape)
See
reshape(long[]) |
INDArray |
BaseNDArray.reshape(int[] shape)
Reshape the ndarray in to the specified dimensions,
possible errors being thrown for invalid shapes
Note here that one dimension can be -1.
|
INDArray |
INDArray.reshape(long... newShape)
Reshapes the ndarray (can't change the length of the ndarray).
|
INDArray |
BaseNDArray.reshape(long... shape) |
INDArray |
INDArray.reshape(long rows,
long columns)
Reshapes the ndarray (can't change the length of the ndarray).
|
INDArray |
BaseNDArray.reshape(long newRows,
long newColumns) |
INDArray |
INDArray.rsub(INDArray other)
Element-wise reverse subtraction (copy op). i.e., other - this
|
INDArray |
BaseNDArray.rsub(INDArray other) |
INDArray |
INDArray.rsub(INDArray other,
INDArray result)
Reverse subtraction
|
INDArray |
BaseNDArray.rsub(INDArray other,
INDArray result) |
INDArray |
INDArray.rsub(Number n)
Reverse subtraction with duplicates - i.e., (n - thisArrayValues)
|
INDArray |
BaseNDArray.rsub(Number n) |
INDArray |
INDArray.rsub(Number n,
INDArray result)
Reverse subtraction
|
INDArray |
BaseNDArray.rsub(Number n,
INDArray result) |
INDArray |
INDArray.rsubColumnVector(INDArray columnVector)
Reverse subtraction of a column vector (copy)
|
INDArray |
BaseNDArray.rsubColumnVector(INDArray columnVector) |
INDArray |
INDArray.rsubi(INDArray other)
Element-wise reverse subtraction (in the place op) - i.e., other - this
|
INDArray |
BaseNDArray.rsubi(INDArray other) |
INDArray |
INDArray.rsubi(INDArray other,
INDArray result)
Reverse subtraction (in-place)
|
INDArray |
BaseNDArray.rsubi(INDArray other,
INDArray result) |
INDArray |
INDArray.rsubi(Number n)
Reverse subtraction in place - i.e., (n - thisArrayValues)
|
INDArray |
BaseNDArray.rsubi(Number n) |
INDArray |
INDArray.rsubi(Number n,
INDArray result)
Reverse in place subtraction
|
INDArray |
BaseNDArray.rsubi(Number n,
INDArray result) |
INDArray |
INDArray.rsubiColumnVector(INDArray columnVector)
In place reverse subtraction of a column vector
|
INDArray |
BaseNDArray.rsubiColumnVector(INDArray columnVector) |
INDArray |
INDArray.rsubiRowVector(INDArray rowVector)
In place reverse subtraction of a row vector
|
INDArray |
BaseNDArray.rsubiRowVector(INDArray rowVector) |
INDArray |
INDArray.rsubRowVector(INDArray rowVector)
Reverse subtraction of a row vector (copy)
|
INDArray |
BaseNDArray.rsubRowVector(INDArray rowVector) |
INDArray |
INDArray.shannonEntropy(int... dimension)
Returns Shannon entropy value for this INDArray along specified dimension(s)
|
INDArray |
BaseNDArray.shannonEntropy(int... dimension) |
INDArray |
INDArray.slice(long i)
Returns the specified slice of this ndarray
|
INDArray |
BaseNDArray.slice(long slice) |
INDArray |
INDArray.slice(long i,
int dimension)
Returns the slice of this from the specified dimension
|
INDArray |
BaseNDArray.slice(long slice,
int dimension) |
INDArray |
INDArray.std(boolean biasCorrected,
boolean keepDims,
int... dimension)
Standard deviation of an ndarray along a dimension
|
INDArray |
BaseNDArray.std(boolean biasCorrected,
boolean keepDims,
int... dimension) |
INDArray |
INDArray.std(boolean biasCorrected,
int... dimension)
Standard deviation of an ndarray along a dimension
|
INDArray |
BaseNDArray.std(boolean biasCorrected,
int... dimension) |
INDArray |
INDArray.std(int... dimension)
Standard deviation of an INDArray along one or more dimensions
|
INDArray |
BaseNDArray.std(int... dimension) |
INDArray |
INDArray.sub(INDArray other)
copy subtraction of two NDArrays
|
INDArray |
BaseNDArray.sub(INDArray other) |
INDArray |
INDArray.sub(INDArray other,
INDArray result)
copy subtraction of two NDArrays
|
INDArray |
BaseNDArray.sub(INDArray other,
INDArray result) |
INDArray |
INDArray.sub(Number n)
Scalar subtraction (copied)
|
INDArray |
BaseNDArray.sub(Number n) |
INDArray |
INDArray.sub(Number n,
INDArray result)
Subtraction of this ndarray
|
INDArray |
BaseNDArray.sub(Number n,
INDArray result) |
INDArray |
INDArray.subColumnVector(INDArray columnVector)
Subtraction of a column vector (copy)
|
INDArray |
BaseNDArray.subColumnVector(INDArray columnVector) |
INDArray |
INDArray.subi(INDArray other)
in place (element wise) subtraction of two NDArrays
|
INDArray |
BaseNDArray.subi(INDArray other) |
INDArray |
INDArray.subi(INDArray other,
INDArray result)
in place (element wise) subtraction of two NDArrays
|
INDArray |
BaseNDArray.subi(INDArray other,
INDArray result)
in place subtraction of two matrices
|
INDArray |
INDArray.subi(Number n)
In place scalar subtraction
|
INDArray |
BaseNDArray.subi(Number n) |
INDArray |
INDArray.subi(Number n,
INDArray result)
In place subtraction of this ndarray
|
INDArray |
BaseNDArray.subi(Number n,
INDArray result) |
INDArray |
INDArray.subiColumnVector(INDArray columnVector)
In place subtraction of a column vector
|
INDArray |
BaseNDArray.subiColumnVector(INDArray columnVector) |
INDArray |
INDArray.subiRowVector(INDArray rowVector)
In place subtraction of a row vector
|
INDArray |
BaseNDArray.subiRowVector(INDArray rowVector) |
INDArray |
INDArray.subRowVector(INDArray rowVector)
Subtraction of a row vector (copy)
|
INDArray |
BaseNDArray.subRowVector(INDArray rowVector) |
INDArray |
INDArray.sum(boolean keepDims,
int... dimension)
Returns the sum along the last dimension of this ndarray
|
INDArray |
BaseNDArray.sum(boolean keepDim,
int... dimension) |
INDArray |
INDArray.sum(INDArray result,
boolean keepDims,
int... dimension)
Returns the sum along the last dimension of this ndarray
|
INDArray |
BaseNDArray.sum(INDArray result,
boolean keepDims,
int... dimension) |
INDArray |
INDArray.sum(INDArray result,
int... dimension)
Returns the sum along the last dimension of this ndarray
|
INDArray |
BaseNDArray.sum(INDArray result,
int... dimension) |
INDArray |
INDArray.sum(int... dimension)
Returns the sum along the last dimension of this ndarray
|
INDArray |
BaseNDArray.sum(int... dimension) |
INDArray |
INDArray.swapAxes(int dimension,
int with)
Mainly here for people coming from numpy.
|
INDArray |
BaseNDArray.swapAxes(int dimension,
int with) |
INDArray |
INDArray.tensorAlongDimension(long index,
int... dimension)
Get the vector along a particular dimension
|
INDArray |
BaseNDArray.tensorAlongDimension(long index,
int... dimension) |
INDArray |
INDArray.transpose()
Flip the rows and columns of a matrix
|
INDArray |
BaseNDArray.transpose() |
INDArray |
INDArray.transposei()
Flip the rows and columns of a matrix, in-place
|
INDArray |
BaseNDArray.transposei()
Return transposed version of this matrix.
|
INDArray |
INDArray.ulike()
This method returns uninitialized array with the same dtype/order/shape as this one
|
INDArray |
BaseNDArray.ulike() |
INDArray |
INDArray.unsafeDuplication()
Perform efficient (but unsafe) duplication.
|
INDArray |
INDArray.unsafeDuplication(boolean blocking)
Perform efficient (but unsafe) duplication.
|
INDArray |
INDArray.var(boolean biasCorrected,
int... dimension)
Returns the overall variance of this ndarray
|
INDArray |
BaseNDArray.var(boolean biasCorrected,
int... dimension) |
INDArray |
INDArray.var(int... dimension)
Returns the overall variance of this ndarray
|
INDArray |
BaseNDArray.var(int... dimension) |
INDArray |
INDArray.vectorAlongDimension(int index,
int dimension)
Get the vector along a particular dimension
|
INDArray |
BaseNDArray.vectorAlongDimension(int index,
int dimension) |
| Modifier and Type | Method and Description |
|---|---|
INDArray |
INDArray.add(INDArray other)
Element-wise copy addition of two NDArrays
|
INDArray |
BaseNDArray.add(INDArray other) |
INDArray |
INDArray.add(INDArray other,
INDArray result)
Element-wise copy addition of two NDArrays
|
INDArray |
BaseNDArray.add(INDArray other,
INDArray result) |
INDArray |
INDArray.add(Number n,
INDArray result)
Addition of this ndarray.
|
INDArray |
BaseNDArray.add(Number n,
INDArray result) |
INDArray |
INDArray.addColumnVector(INDArray columnVector)
Addition of a column vector (copy)
|
INDArray |
BaseNDArray.addColumnVector(INDArray columnVector) |
INDArray |
INDArray.addi(INDArray other)
in place (element wise) addition of two NDArrays
|
INDArray |
BaseNDArray.addi(INDArray other) |
INDArray |
INDArray.addi(INDArray other,
INDArray result)
in place (element wise) addition of two NDArrays
|
INDArray |
BaseNDArray.addi(INDArray other,
INDArray result) |
INDArray |
INDArray.addi(Number n,
INDArray result)
In place addition
|
INDArray |
BaseNDArray.addi(Number n,
INDArray result) |
INDArray |
INDArray.addiColumnVector(INDArray columnVector)
In place addition of a column vector
|
INDArray |
BaseNDArray.addiColumnVector(INDArray columnVector) |
INDArray |
INDArray.addiRowVector(INDArray rowVector)
In place addition of a row vector
|
INDArray |
BaseNDArray.addiRowVector(INDArray rowVector) |
INDArray |
INDArray.addRowVector(INDArray rowVector)
Addition of a row vector (copy)
|
INDArray |
BaseNDArray.addRowVector(INDArray rowVector) |
protected void |
BaseNDArray.assertSlice(INDArray put,
long slice) |
INDArray |
INDArray.assign(INDArray arr)
Assign all of the elements in the given ndarray to this ndarray
|
INDArray |
BaseNDArray.assign(INDArray arr) |
INDArray |
INDArray.assignIf(INDArray arr,
Condition condition)
Assign all elements from given ndarray that are matching given condition,
ndarray to this ndarray
|
INDArray |
BaseNDArray.assignIf(INDArray arr,
Condition condition) |
INDArray |
INDArray.broadcast(INDArray result)
Broadcasts this ndarray to be the specified shape
|
INDArray |
BaseNDArray.broadcast(INDArray result) |
double |
INDArray.distance1(INDArray other)
Returns the (1-norm) distance.
|
double |
BaseNDArray.distance1(INDArray other) |
double |
INDArray.distance2(INDArray other)
Returns the (euclidean) distance.
|
double |
BaseNDArray.distance2(INDArray other) |
INDArray |
INDArray.div(INDArray other)
Copy (element wise) division of two NDArrays
|
INDArray |
BaseNDArray.div(INDArray other) |
INDArray |
INDArray.div(INDArray other,
INDArray result)
copy (element wise) division of two NDArrays
|
INDArray |
BaseNDArray.div(INDArray other,
INDArray result) |
INDArray |
INDArray.div(Number n,
INDArray result)
Division if ndarray by number
|
INDArray |
BaseNDArray.div(Number n,
INDArray result) |
INDArray |
INDArray.divColumnVector(INDArray columnVector)
Division of a column vector (copy)
|
INDArray |
BaseNDArray.divColumnVector(INDArray columnVector) |
INDArray |
INDArray.divi(INDArray other)
in place (element wise) division of two NDArrays
|
INDArray |
BaseNDArray.divi(INDArray other) |
INDArray |
INDArray.divi(INDArray other,
INDArray result)
in place (element wise) division of two NDArrays
|
INDArray |
BaseNDArray.divi(INDArray other,
INDArray result) |
INDArray |
INDArray.divi(Number n,
INDArray result)
In place division of this ndarray
|
INDArray |
BaseNDArray.divi(Number n,
INDArray result) |
INDArray |
INDArray.diviColumnVector(INDArray columnVector)
In place division of a column vector
|
INDArray |
BaseNDArray.diviColumnVector(INDArray columnVector) |
INDArray |
INDArray.diviRowVector(INDArray rowVector)
In place division of a row vector
|
INDArray |
BaseNDArray.diviRowVector(INDArray rowVector) |
INDArray |
INDArray.divRowVector(INDArray rowVector)
Division of a row vector (copy)
|
INDArray |
BaseNDArray.divRowVector(INDArray rowVector) |
protected INDArray |
BaseNDArray.doColumnWise(INDArray columnVector,
char operation)
Do a row wise op (a,s,m,d)
a : add
s : subtract
m : multiply
d : divide
h : reverse subtraction
t : reverse division
|
protected INDArray |
BaseNDArray.doRowWise(INDArray rowVector,
char operation)
Do a row wise op (a,s,m,d)
a : add
s : subtract
m : multiply
d : divide
h : reverse subtraction
t : reverse division
|
INDArray |
INDArray.eps(INDArray other)
Returns the binary ndarray for "Epsilon equals" comparison.
|
INDArray |
BaseNDArray.eps(INDArray other) |
INDArray |
INDArray.eq(INDArray other)
Returns the binary ndarray for "Equals" comparison.
|
INDArray |
BaseNDArray.eq(INDArray other) |
boolean |
INDArray.equalShapes(INDArray other)
This method checks 2 INDArrays for equal shapes.
|
boolean |
BaseNDArray.equalShapes(INDArray other) |
INDArray |
INDArray.fmod(INDArray denominator)
remainder of division
|
INDArray |
BaseNDArray.fmod(INDArray denominator) |
INDArray |
INDArray.fmod(INDArray denominator,
INDArray result)
remainder of division
|
INDArray |
BaseNDArray.fmod(INDArray denominator,
INDArray result) |
INDArray |
INDArray.fmod(Number denominator,
INDArray result)
remainder of division by scalar.
|
INDArray |
BaseNDArray.fmod(Number denominator,
INDArray result) |
INDArray |
INDArray.fmodi(INDArray denominator)
In place fmod
|
INDArray |
BaseNDArray.fmodi(INDArray denominator) |
INDArray |
INDArray.get(INDArray indices)
Get the elements from this ndarray based on the specified indices
|
INDArray |
BaseNDArray.get(INDArray indices) |
protected double |
BaseNDArray.getPercentile(Number quantile,
INDArray sorted) |
INDArray |
INDArray.getWhere(INDArray comp,
Condition condition)
Boolean indexing:
Return the element if it fulfills the condition in
result array
|
INDArray |
BaseNDArray.getWhere(INDArray comp,
Condition condition) |
INDArray |
INDArray.gt(INDArray other)
Returns the binary ndarray for "Greater Than" comparison.
|
INDArray |
BaseNDArray.gt(INDArray other) |
INDArray |
INDArray.lt(INDArray other)
Returns the binary ndarray for "Less" comparison.
|
INDArray |
BaseNDArray.lt(INDArray other) |
INDArray |
INDArray.match(INDArray comp,
Condition condition)
Return a mask on whether each element matches the given condition
|
INDArray |
BaseNDArray.match(INDArray comp,
Condition condition) |
INDArray |
INDArray.mean(INDArray result,
boolean keepDims,
int... dimension)
Returns the overall mean of this ndarray
|
INDArray |
BaseNDArray.mean(INDArray result,
boolean keepDims,
int... dimension) |
INDArray |
INDArray.mean(INDArray result,
int... dimension)
Returns the overall mean of this ndarray
|
INDArray |
BaseNDArray.mean(INDArray result,
int... dimension) |
INDArray |
INDArray.mmul(INDArray other)
Perform a copy matrix multiplication
|
INDArray |
BaseNDArray.mmul(INDArray other) |
INDArray |
INDArray.mmul(INDArray other,
INDArray result)
Perform an copy matrix multiplication
|
INDArray |
BaseNDArray.mmul(INDArray other,
INDArray result)
Perform an copy matrix multiplication
|
INDArray |
INDArray.mmul(INDArray other,
INDArray result,
MMulTranspose mMulTranspose)
Perform an copy matrix multiplication
|
INDArray |
BaseNDArray.mmul(INDArray other,
INDArray result,
MMulTranspose mMulTranspose) |
INDArray |
INDArray.mmul(INDArray other,
MMulTranspose mMulTranspose)
Perform a copy matrix multiplication
|
INDArray |
BaseNDArray.mmul(INDArray other,
MMulTranspose mMulTranspose) |
INDArray |
INDArray.mmuli(INDArray other)
Perform an inplace matrix multiplication
|
INDArray |
BaseNDArray.mmuli(INDArray other) |
INDArray |
INDArray.mmuli(INDArray other,
INDArray result)
Perform an inplace matrix multiplication
|
INDArray |
BaseNDArray.mmuli(INDArray other,
INDArray result) |
INDArray |
INDArray.mmuli(INDArray other,
INDArray result,
MMulTranspose transpose)
Perform an in place matrix multiplication
|
INDArray |
BaseNDArray.mmuli(INDArray other,
INDArray result,
MMulTranspose transpose) |
INDArray |
INDArray.mmuli(INDArray other,
MMulTranspose transpose)
Perform an copy matrix multiplication
|
INDArray |
BaseNDArray.mmuli(INDArray other,
MMulTranspose transpose) |
INDArray |
INDArray.mul(INDArray other)
copy (element wise) multiplication of two NDArrays
|
INDArray |
BaseNDArray.mul(INDArray other) |
INDArray |
INDArray.mul(INDArray other,
INDArray result)
copy (element wise) multiplication of two NDArrays
|
INDArray |
BaseNDArray.mul(INDArray other,
INDArray result) |
INDArray |
INDArray.mul(Number n,
INDArray result)
Multiplication of ndarray.
|
INDArray |
BaseNDArray.mul(Number n,
INDArray result) |
INDArray |
INDArray.mulColumnVector(INDArray columnVector)
Multiplication of a column vector (copy)
|
INDArray |
BaseNDArray.mulColumnVector(INDArray columnVector) |
INDArray |
INDArray.muli(INDArray other)
in place (element wise) multiplication of two NDArrays
|
INDArray |
BaseNDArray.muli(INDArray other) |
INDArray |
INDArray.muli(INDArray other,
INDArray result)
in place (element wise) multiplication of two NDArrays
|
INDArray |
BaseNDArray.muli(INDArray other,
INDArray result) |
INDArray |
INDArray.muli(Number n,
INDArray result)
In place multiplication of this ndarray
|
INDArray |
BaseNDArray.muli(Number n,
INDArray result) |
INDArray |
INDArray.muliColumnVector(INDArray columnVector)
In place multiplication of a column vector
|
INDArray |
BaseNDArray.muliColumnVector(INDArray columnVector) |
INDArray |
INDArray.muliRowVector(INDArray rowVector)
In place multiplication of a row vector
|
INDArray |
BaseNDArray.muliRowVector(INDArray rowVector) |
INDArray |
INDArray.mulRowVector(INDArray rowVector)
Multiplication of a row vector (copy)
|
INDArray |
BaseNDArray.mulRowVector(INDArray rowVector) |
INDArray |
INDArray.neq(INDArray other)
Returns the binary ndarray for "Not equals" comparison.
|
INDArray |
BaseNDArray.neq(INDArray other) |
INDArray |
INDArray.put(INDArray indices,
INDArray element)
Put element in to the indices denoted by
the indices ndarray.
|
INDArray |
BaseNDArray.put(INDArray indices,
INDArray element) |
INDArray |
INDArray.put(INDArrayIndex[] indices,
INDArray element)
Put the elements of the ndarray in to the specified indices
|
INDArray |
BaseNDArray.put(INDArrayIndex[] indices,
INDArray element) |
INDArray |
INDArray.put(int[] indices,
INDArray element)
Inserts the element at the specified index
|
INDArray |
BaseNDArray.put(int[] indices,
INDArray element) |
INDArray |
INDArray.put(int i,
INDArray element)
Inserts the element at the specified index
|
INDArray |
BaseNDArray.put(int i,
INDArray element) |
INDArray |
INDArray.put(int i,
int j,
INDArray element)
Inserts the element at the specified index
|
INDArray |
BaseNDArray.put(int i,
int j,
INDArray element) |
INDArray |
INDArray.putColumn(int column,
INDArray toPut)
Insert a column in to this array
Will throw an exception if this ndarray is not a matrix
|
INDArray |
BaseNDArray.putColumn(int column,
INDArray toPut) |
INDArray |
INDArray.putiColumnVector(INDArray columnVector)
In place assignment of a column vector
|
INDArray |
BaseNDArray.putiColumnVector(INDArray columnVector) |
INDArray |
INDArray.putiRowVector(INDArray rowVector)
in place assignment of row vector, to each row of this array
|
INDArray |
BaseNDArray.putiRowVector(INDArray rowVector) |
INDArray |
INDArray.putRow(long row,
INDArray toPut)
Insert a row in to this array
Will throw an exception if this ndarray is not a matrix
|
INDArray |
BaseNDArray.putRow(long row,
INDArray toPut) |
INDArray |
INDArray.putSlice(int slice,
INDArray put)
Assigns the given matrix (put) to the specified slice
|
INDArray |
BaseNDArray.putSlice(int slice,
INDArray put) |
INDArray |
INDArray.putWhere(INDArray comp,
INDArray put,
Condition condition)
Assign the element according to the comparison array
|
INDArray |
BaseNDArray.putWhere(INDArray comp,
INDArray put,
Condition condition) |
INDArray |
INDArray.putWhere(Number comp,
INDArray put,
Condition condition)
Assign the element according to the comparison array
|
INDArray |
BaseNDArray.putWhere(Number comp,
INDArray put,
Condition condition) |
INDArray |
INDArray.putWhereWithMask(INDArray mask,
INDArray put)
Use a pre computed mask for assigning arrays
|
INDArray |
BaseNDArray.putWhereWithMask(INDArray mask,
INDArray put) |
INDArray |
INDArray.putWhereWithMask(INDArray mask,
Number put)
Use a pre computed mask for assigning arrays
|
INDArray |
BaseNDArray.putWhereWithMask(INDArray mask,
Number put) |
INDArray |
INDArray.rdiv(INDArray other)
Reverse division, elements wise. i.e., other / this
|
INDArray |
BaseNDArray.rdiv(INDArray other) |
INDArray |
INDArray.rdiv(INDArray other,
INDArray result)
Reverse division
|
INDArray |
BaseNDArray.rdiv(INDArray other,
INDArray result) |
INDArray |
INDArray.rdiv(Number n,
INDArray result)
Reverse division (number / ndarray)
|
INDArray |
BaseNDArray.rdiv(Number n,
INDArray result) |
INDArray |
INDArray.rdivColumnVector(INDArray columnVector)
Reverse division of a column vector (copy)
|
INDArray |
BaseNDArray.rdivColumnVector(INDArray columnVector) |
INDArray |
INDArray.rdivi(INDArray other)
Reverse divsion (in place). i.e., other / this
|
INDArray |
BaseNDArray.rdivi(INDArray other) |
INDArray |
INDArray.rdivi(INDArray other,
INDArray result)
Reverse division (in-place)
|
INDArray |
BaseNDArray.rdivi(INDArray other,
INDArray result) |
INDArray |
INDArray.rdivi(Number n,
INDArray result)
Reverse in place division
|
INDArray |
BaseNDArray.rdivi(Number n,
INDArray result) |
INDArray |
INDArray.rdiviColumnVector(INDArray columnVector)
In place reverse divison of a column vector
|
INDArray |
BaseNDArray.rdiviColumnVector(INDArray columnVector) |
INDArray |
INDArray.rdiviRowVector(INDArray rowVector)
In place reverse division of a column vector
|
INDArray |
BaseNDArray.rdiviRowVector(INDArray rowVector) |
INDArray |
INDArray.rdivRowVector(INDArray rowVector)
Reverse division of a column vector (copy)
|
INDArray |
BaseNDArray.rdivRowVector(INDArray rowVector) |
INDArray |
INDArray.remainder(INDArray denominator)
Remainder operator
|
INDArray |
BaseNDArray.remainder(INDArray denominator) |
INDArray |
INDArray.remainder(INDArray denominator,
INDArray result)
Remainder operator
|
INDArray |
BaseNDArray.remainder(INDArray denominator,
INDArray result) |
INDArray |
INDArray.remainder(Number denominator,
INDArray result)
The scalar remainder
|
INDArray |
BaseNDArray.remainder(Number denominator,
INDArray result) |
INDArray |
INDArray.remainderi(INDArray denominator)
In place remainder
|
INDArray |
BaseNDArray.remainderi(INDArray denominator) |
INDArray |
INDArray.replaceWhere(INDArray arr,
Condition condition)
Replaces all elements in this ndarray that are matching give condition, with corresponding elements from given array
|
INDArray |
BaseNDArray.replaceWhere(INDArray arr,
Condition condition) |
INDArray |
INDArray.rsub(INDArray other)
Element-wise reverse subtraction (copy op). i.e., other - this
|
INDArray |
BaseNDArray.rsub(INDArray other) |
INDArray |
INDArray.rsub(INDArray other,
INDArray result)
Reverse subtraction
|
INDArray |
BaseNDArray.rsub(INDArray other,
INDArray result) |
INDArray |
INDArray.rsub(Number n,
INDArray result)
Reverse subtraction
|
INDArray |
BaseNDArray.rsub(Number n,
INDArray result) |
INDArray |
INDArray.rsubColumnVector(INDArray columnVector)
Reverse subtraction of a column vector (copy)
|
INDArray |
BaseNDArray.rsubColumnVector(INDArray columnVector) |
INDArray |
INDArray.rsubi(INDArray other)
Element-wise reverse subtraction (in the place op) - i.e., other - this
|
INDArray |
BaseNDArray.rsubi(INDArray other) |
INDArray |
INDArray.rsubi(INDArray other,
INDArray result)
Reverse subtraction (in-place)
|
INDArray |
BaseNDArray.rsubi(INDArray other,
INDArray result) |
INDArray |
INDArray.rsubi(Number n,
INDArray result)
Reverse in place subtraction
|
INDArray |
BaseNDArray.rsubi(Number n,
INDArray result) |
INDArray |
INDArray.rsubiColumnVector(INDArray columnVector)
In place reverse subtraction of a column vector
|
INDArray |
BaseNDArray.rsubiColumnVector(INDArray columnVector) |
INDArray |
INDArray.rsubiRowVector(INDArray rowVector)
In place reverse subtraction of a row vector
|
INDArray |
BaseNDArray.rsubiRowVector(INDArray rowVector) |
INDArray |
INDArray.rsubRowVector(INDArray rowVector)
Reverse subtraction of a row vector (copy)
|
INDArray |
BaseNDArray.rsubRowVector(INDArray rowVector) |
double |
INDArray.squaredDistance(INDArray other)
Returns the square of the Euclidean distance.
|
double |
BaseNDArray.squaredDistance(INDArray other) |
INDArray |
INDArray.sub(INDArray other)
copy subtraction of two NDArrays
|
INDArray |
BaseNDArray.sub(INDArray other) |
INDArray |
INDArray.sub(INDArray other,
INDArray result)
copy subtraction of two NDArrays
|
INDArray |
BaseNDArray.sub(INDArray other,
INDArray result) |
INDArray |
INDArray.sub(Number n,
INDArray result)
Subtraction of this ndarray
|
INDArray |
BaseNDArray.sub(Number n,
INDArray result) |
INDArray |
INDArray.subColumnVector(INDArray columnVector)
Subtraction of a column vector (copy)
|
INDArray |
BaseNDArray.subColumnVector(INDArray columnVector) |
INDArray |
INDArray.subi(INDArray other)
in place (element wise) subtraction of two NDArrays
|
INDArray |
BaseNDArray.subi(INDArray other) |
INDArray |
INDArray.subi(INDArray other,
INDArray result)
in place (element wise) subtraction of two NDArrays
|
INDArray |
BaseNDArray.subi(INDArray other,
INDArray result)
in place subtraction of two matrices
|
INDArray |
INDArray.subi(Number n,
INDArray result)
In place subtraction of this ndarray
|
INDArray |
BaseNDArray.subi(Number n,
INDArray result) |
INDArray |
INDArray.subiColumnVector(INDArray columnVector)
In place subtraction of a column vector
|
INDArray |
BaseNDArray.subiColumnVector(INDArray columnVector) |
INDArray |
INDArray.subiRowVector(INDArray rowVector)
In place subtraction of a row vector
|
INDArray |
BaseNDArray.subiRowVector(INDArray rowVector) |
INDArray |
INDArray.subRowVector(INDArray rowVector)
Subtraction of a row vector (copy)
|
INDArray |
BaseNDArray.subRowVector(INDArray rowVector) |
INDArray |
INDArray.sum(INDArray result,
boolean keepDims,
int... dimension)
Returns the sum along the last dimension of this ndarray
|
INDArray |
BaseNDArray.sum(INDArray result,
boolean keepDims,
int... dimension) |
INDArray |
INDArray.sum(INDArray result,
int... dimension)
Returns the sum along the last dimension of this ndarray
|
INDArray |
BaseNDArray.sum(INDArray result,
int... dimension) |
| Modifier and Type | Method and Description |
|---|---|
void |
INDArray.sliceVectors(List<INDArray> list)
Flattens the array for linear indexing in list.
|
void |
BaseNDArray.sliceVectors(List<INDArray> list) |
| Constructor and Description |
|---|
BaseNDArrayProxy(INDArray anInstance) |
| Constructor and Description |
|---|
BaseNDArray(List<INDArray> slices,
int[] shape)
Create an ndarray from the specified slices.
|
BaseNDArray(List<INDArray> slices,
int[] shape,
char ordering)
Create an ndarray from the specified slices.
|
BaseNDArray(List<INDArray> slices,
int[] shape,
int[] stride)
Create an ndarray from the specified slices.
|
BaseNDArray(List<INDArray> slices,
int[] shape,
int[] stride,
char ordering)
Create an ndarray from the specified slices.
|
BaseNDArray(List<INDArray> slices,
long[] shape) |
BaseNDArray(List<INDArray> slices,
long[] shape,
char ordering) |
BaseNDArray(List<INDArray> slices,
long[] shape,
long[] stride) |
BaseNDArray(List<INDArray> slices,
long[] shape,
long[] stride,
char ordering) |
| Modifier and Type | Field and Description |
|---|---|
protected INDArray |
BaseOp.dimensionz |
protected INDArray |
BaseOp.x |
protected INDArray |
BaseOp.y |
protected INDArray |
BaseOp.z |
| Modifier and Type | Field and Description |
|---|---|
protected Map<Integer,INDArray> |
BaseOpContext.fastpath_in |
protected Map<Integer,INDArray> |
BaseOpContext.fastpath_out |
protected List<INDArray> |
DynamicCustomOp.inputArguments |
protected List<INDArray> |
DynamicCustomOp.outputArguments |
| Modifier and Type | Method and Description |
|---|---|
INDArray |
ScalarOp.dimensions()
This method returns target dimensions for this op
|
INDArray |
ReduceOp.dimensions()
This method returns dimensions for this op
|
INDArray |
IndexAccumulation.dimensions()
This method returns dimensions for this op
|
INDArray |
BroadcastOp.dimensions() |
INDArray |
BaseOp.dimensions() |
INDArray |
DynamicCustomOp.getInputArgument(int index) |
INDArray |
CustomOp.getInputArgument(int index) |
INDArray |
BaseOp.getInputArgument(int index) |
INDArray |
DynamicCustomOp.getOutputArgument(int index) |
INDArray |
CustomOp.getOutputArgument(int index) |
INDArray |
LossFunction.input()
The true
|
INDArray[] |
DynamicCustomOp.inputArguments() |
INDArray[] |
CustomOp.inputArguments() |
INDArray |
ReduceOp.noOp()
Returns the no op version
of the input
Basically when a reduce can't happen (eg: sum(0) on a row vector)
you have a no op state for a given reduction.
|
INDArray |
BaseReduceOp.noOp() |
INDArray |
LossFunction.output()
The guess
|
INDArray[] |
DynamicCustomOp.outputArguments() |
INDArray[] |
CustomOp.outputArguments() |
INDArray |
ScalarOp.scalar()
The normal scalar
|
INDArray |
BaseScalarOp.scalar() |
INDArray |
BaseScalarBoolOp.scalar() |
protected static INDArray[] |
DynamicCustomOp.wrapOrNull(INDArray in) |
INDArray |
Op.x()
The origin ndarray
|
INDArray |
BaseOp.x() |
INDArray |
Op.y()
The pairwise op ndarray
|
INDArray |
BaseOp.y() |
INDArray |
Op.z()
The resulting ndarray
|
INDArray |
BaseTransformOp.z() |
INDArray |
BaseScalarOp.z() |
INDArray |
BaseScalarBoolOp.z() |
INDArray |
BaseOp.z() |
| Modifier and Type | Method and Description |
|---|---|
List<INDArray> |
OpContext.getInputArrays()
This method returns List of input arrays defined within this context
|
List<INDArray> |
BaseOpContext.getInputArrays() |
List<INDArray> |
OpContext.getOutputArrays()
This method returns List of output arrays defined within this context
|
List<INDArray> |
BaseOpContext.getOutputArrays() |
| Modifier and Type | Method and Description |
|---|---|
void |
DynamicCustomOp.addInputArgument(INDArray... arg) |
void |
CustomOp.addInputArgument(INDArray... arg) |
DynamicCustomOp.DynamicCustomOpsBuilder |
DynamicCustomOp.DynamicCustomOpsBuilder.addInputs(INDArray... inputs)
This method
takes arbitrary number of input INDArrays in, as Op input
Note that this ACCUMULATES arguments.
|
void |
DynamicCustomOp.addOutputArgument(INDArray... arg) |
void |
CustomOp.addOutputArgument(INDArray... arg) |
DynamicCustomOp.DynamicCustomOpsBuilder |
DynamicCustomOp.DynamicCustomOpsBuilder.addOutputs(INDArray... outputs)
This method takes arbitrary number of
output INDArrays in, to store operation result
Note that this ACCUMULATES arguments.
|
void |
DynamicCustomOp.removeInputArgument(INDArray arg) |
void |
CustomOp.removeInputArgument(INDArray arg) |
void |
DynamicCustomOp.removeOutputArgument(INDArray arg) |
void |
CustomOp.removeOutputArgument(INDArray arg) |
void |
DynamicCustomOp.setInputArgument(int index,
INDArray input) |
void |
DynamicCustomOp.setInputArguments(INDArray... inputs) |
void |
OpContext.setInputArray(int index,
INDArray array)
This method adds INDArray as input argument for future op call
|
void |
BaseOpContext.setInputArray(int index,
INDArray array) |
void |
OpContext.setInputArrays(INDArray... arrays)
This method sets provided arrays as input arrays
|
void |
BaseOpContext.setInputArrays(INDArray... arrays) |
void |
DynamicCustomOp.setOutputArgument(int index,
INDArray output) |
void |
OpContext.setOutputArray(int index,
INDArray array)
This method adds INDArray as output for future op call
|
void |
BaseOpContext.setOutputArray(int index,
INDArray array) |
void |
OpContext.setOutputArrays(INDArray... arrays)
This method sets provided arrays as output arrays
|
void |
BaseOpContext.setOutputArrays(INDArray... arrays) |
void |
ScalarOp.setScalar(INDArray scalar) |
void |
BaseScalarOp.setScalar(INDArray scalar) |
void |
BaseScalarBoolOp.setScalar(INDArray scalar) |
void |
Op.setX(INDArray x)
set x (the input ndarray)
|
void |
BaseOp.setX(INDArray x) |
void |
Op.setY(INDArray y)
set y(the pairwise ndarray)
|
void |
BaseOp.setY(INDArray y) |
void |
Op.setZ(INDArray z)
set z (the solution ndarray)
|
void |
BaseOp.setZ(INDArray z) |
protected static INDArray[] |
DynamicCustomOp.wrapOrNull(INDArray in) |
| Modifier and Type | Method and Description |
|---|---|
void |
OpContext.setInputArrays(List<INDArray> arrays)
This method sets provided arrays as input arrays
|
void |
BaseOpContext.setInputArrays(List<INDArray> arrays) |
void |
OpContext.setOutputArrays(List<INDArray> arrays)
This method sets provided arrays as output arrays
|
void |
BaseOpContext.setOutputArrays(List<INDArray> arrays) |
| Constructor and Description |
|---|
BaseBroadcastBoolOp(INDArray x,
INDArray y,
INDArray z,
int... dimension) |
BaseBroadcastOp(INDArray x,
INDArray y,
INDArray z,
int... dimension) |
BaseIndexAccumulation(INDArray x,
INDArray z,
int[] dimensions) |
BaseIndexAccumulation(INDArray x,
int[] dimensions) |
BaseOp(INDArray x)
An op for one ndarray
|
BaseOp(INDArray x,
INDArray z)
Specify an alternative result array
|
BaseOp(INDArray x,
INDArray y,
INDArray z) |
BaseReduceBoolOp(INDArray x,
INDArray z,
boolean keepDims,
int[] dimensions) |
BaseReduceBoolOp(INDArray x,
INDArray z,
int... dimensions) |
BaseReduceBoolOp(INDArray x,
int... dimensions) |
BaseReduceFloatOp(INDArray x,
boolean keepDims,
int... dimensions) |
BaseReduceFloatOp(INDArray input,
INDArray output,
boolean keepDims,
int... dimensions) |
BaseReduceFloatOp(INDArray x,
INDArray y,
INDArray z,
boolean keepDims,
int... dimensions) |
BaseReduceFloatOp(INDArray x,
INDArray y,
INDArray z,
int... dimensions) |
BaseReduceFloatOp(INDArray x,
INDArray z,
int... dimensions) |
BaseReduceFloatOp(INDArray x,
int... dimensions) |
BaseReduceLongOp(INDArray x,
INDArray z,
int... dimensions) |
BaseReduceLongOp(INDArray x,
int... dimensions) |
BaseReduceOp(INDArray x,
boolean keepDims,
int... dimensions) |
BaseReduceOp(INDArray x,
INDArray y,
INDArray z,
boolean keepDims,
int[] dimensions) |
BaseReduceOp(INDArray x,
INDArray y,
INDArray z,
int... dimensions) |
BaseReduceOp(INDArray x,
INDArray y,
int... dimensions) |
BaseReduceOp(INDArray x,
int... dimensions) |
BaseReduceSameOp(INDArray x,
boolean keepDims,
int... dimensions) |
BaseReduceSameOp(INDArray x,
INDArray z,
boolean keepDims,
int[] dimensions) |
BaseReduceSameOp(INDArray x,
INDArray y,
INDArray z,
int... dimensions) |
BaseReduceSameOp(INDArray x,
int... dimensions) |
BaseScalarBoolOp(INDArray x,
INDArray y,
INDArray z,
Number num) |
BaseScalarBoolOp(INDArray x,
INDArray z,
Number set) |
BaseScalarBoolOp(INDArray x,
Number num) |
BaseScalarOp(INDArray x,
INDArray y,
INDArray z,
Number num) |
BaseScalarOp(INDArray x,
INDArray z,
Number set) |
BaseScalarOp(INDArray x,
Number num) |
BaseTransformAnyOp(INDArray x) |
BaseTransformAnyOp(INDArray x,
INDArray z) |
BaseTransformAnyOp(INDArray x,
INDArray y,
INDArray z) |
BaseTransformBoolOp(INDArray x) |
BaseTransformBoolOp(INDArray x,
INDArray z) |
BaseTransformBoolOp(INDArray x,
INDArray y,
INDArray z) |
BaseTransformFloatOp(INDArray x) |
BaseTransformFloatOp(INDArray x,
INDArray z) |
BaseTransformOp(INDArray x) |
BaseTransformOp(INDArray x,
INDArray z) |
BaseTransformOp(INDArray x,
INDArray y,
INDArray z) |
BaseTransformSameOp(INDArray x) |
BaseTransformSameOp(INDArray x,
INDArray z) |
BaseTransformSameOp(INDArray x,
INDArray y,
INDArray z) |
BaseTransformStrictOp(INDArray x) |
BaseTransformStrictOp(INDArray x,
INDArray z) |
DynamicCustomOp(INDArray[] inputs,
INDArray[] outputs)
Initialize this operation for execution (pre created ndarrays)
|
DynamicCustomOp(INDArray[] inputs,
INDArray[] outputs)
Initialize this operation for execution (pre created ndarrays)
|
DynamicCustomOp(String opName,
INDArray[] inputs,
INDArray[] outputs)
Initialize this operation for execution (pre created ndarrays)
|
DynamicCustomOp(String opName,
INDArray[] inputs,
INDArray[] outputs)
Initialize this operation for execution (pre created ndarrays)
|
DynamicCustomOp(String opName,
INDArray[] inputs,
INDArray[] outputs,
List<Double> tArguments,
int[] iArguments) |
DynamicCustomOp(String opName,
INDArray[] inputs,
INDArray[] outputs,
List<Double> tArguments,
int[] iArguments) |
DynamicCustomOp(String opName,
INDArray[] inputs,
INDArray[] outputs,
List<Double> tArguments,
List<Integer> iArguments)
Initialize this custom op with all of the
inputs, outputs, and respective
arguments for execution
|
DynamicCustomOp(String opName,
INDArray[] inputs,
INDArray[] outputs,
List<Double> tArguments,
List<Integer> iArguments)
Initialize this custom op with all of the
inputs, outputs, and respective
arguments for execution
|
DynamicCustomOp(String opName,
INDArray input,
INDArray output,
List<Double> tArguments,
int[] iArguments) |
| Modifier and Type | Field and Description |
|---|---|
protected List<INDArray> |
BaseAggregate.arguments |
| Modifier and Type | Method and Description |
|---|---|
List<INDArray> |
BaseAggregate.getArguments() |
List<INDArray> |
Aggregate.getArguments() |
| Constructor and Description |
|---|
AggregateAxpy(INDArray x,
INDArray y,
double alpha)
Deprecated.
|
AggregateGEMM(int Order,
int TransA,
int TransB,
int M,
int N,
int K,
double alpha,
INDArray A,
int lda,
INDArray B,
int ldb,
double beta,
INDArray C,
int ldc) |
| Modifier and Type | Method and Description |
|---|---|
INDArray |
ScatterUpdate.getInputArgument(int index) |
INDArray |
ScatterUpdate.getOutputArgument(int index) |
INDArray |
BarnesHutSymmetrize.getSymmetrizedCols() |
INDArray |
BarnesHutSymmetrize.getSymmetrizedValues() |
INDArray[] |
ScatterUpdate.inputArguments() |
INDArray[] |
ScatterUpdate.outputArguments() |
| Modifier and Type | Method and Description |
|---|---|
void |
ScatterUpdate.addInputArgument(INDArray... arg) |
void |
ScatterUpdate.addOutputArgument(INDArray... arg) |
void |
ScatterUpdate.removeInputArgument(INDArray arg) |
void |
ScatterUpdate.removeOutputArgument(INDArray arg) |
| Modifier and Type | Method and Description |
|---|---|
INDArray[] |
OpExecutioner.allocateOutputArrays(CustomOp op)
Equivalent to calli
|
INDArray[] |
DefaultOpExecutioner.allocateOutputArrays(CustomOp op) |
INDArray |
OpExecutioner.bitmapDecode(INDArray encoded,
INDArray target) |
INDArray |
DefaultOpExecutioner.bitmapDecode(INDArray encoded,
INDArray target) |
INDArray |
OpExecutioner.bitmapEncode(INDArray indArray,
double threshold) |
INDArray |
DefaultOpExecutioner.bitmapEncode(INDArray indArray,
double threshold) |
INDArray |
OpExecutioner.exec(BroadcastOp broadcast)
Execute a broadcast op, possibly along one or more dimensions
|
INDArray |
DefaultOpExecutioner.exec(BroadcastOp broadcast) |
INDArray[] |
OpExecutioner.exec(CustomOp op) |
INDArray[] |
DefaultOpExecutioner.exec(CustomOp op) |
INDArray[] |
OpExecutioner.exec(CustomOp op,
OpContext context)
This method executes op with given context
|
INDArray[] |
DefaultOpExecutioner.exec(CustomOp op,
OpContext context) |
INDArray |
OpExecutioner.exec(IndexAccumulation indexAccum)
Execute an index accumulation along one or more dimensions
|
INDArray |
DefaultOpExecutioner.exec(IndexAccumulation op) |
INDArray |
OpExecutioner.exec(Op op)
Execute the operation
|
INDArray |
DefaultOpExecutioner.exec(Op op) |
INDArray |
OpExecutioner.exec(RandomOp op)
This method executes specified RandomOp using default RNG available via Nd4j.getRandom()
|
INDArray |
DefaultOpExecutioner.exec(RandomOp op)
This method executes specified RandomOp using default RNG available via Nd4j.getRandom()
|
INDArray |
OpExecutioner.exec(RandomOp op,
Random rng)
This method executes specific RandomOp against specified RNG
|
INDArray |
DefaultOpExecutioner.exec(RandomOp op,
Random rng)
This method executes specific RandomOp against specified RNG
|
INDArray |
OpExecutioner.exec(ReduceOp reduceOp)
Execute a reduceOp, possibly along one or more dimensions
|
INDArray |
DefaultOpExecutioner.exec(ReduceOp op) |
INDArray |
OpExecutioner.exec(ScalarOp broadcast)
Execute ScalarOp
|
INDArray |
DefaultOpExecutioner.exec(ScalarOp op) |
INDArray |
OpExecutioner.exec(Variance accumulation)
Execute an variance accumulation op, possibly along one or more dimensions
|
INDArray |
DefaultOpExecutioner.exec(Variance accumulation) |
INDArray |
OpExecutioner.thresholdDecode(INDArray encoded,
INDArray target)
This method decodes thresholds array, and puts it into target array
|
INDArray |
DefaultOpExecutioner.thresholdDecode(INDArray encoded,
INDArray target) |
INDArray |
OpExecutioner.thresholdEncode(INDArray input,
double threshold)
This method encodes array as thresholds, updating input array at the same time
|
INDArray |
DefaultOpExecutioner.thresholdEncode(INDArray input,
double threshold) |
INDArray |
OpExecutioner.thresholdEncode(INDArray input,
double threshold,
Integer boundary)
This method encodes array as thresholds, updating input array at the same time
|
INDArray |
DefaultOpExecutioner.thresholdEncode(INDArray input,
double threshold,
Integer boundary) |
| Modifier and Type | Method and Description |
|---|---|
Map<String,INDArray> |
OpExecutioner.executeGraph(long id,
Map<String,INDArray> map,
Map<String,Integer> reverseMap) |
Map<String,INDArray> |
DefaultOpExecutioner.executeGraph(long id,
Map<String,INDArray> map,
Map<String,Integer> reverseMap) |
| Modifier and Type | Method and Description |
|---|---|
String |
DefaultOpExecutioner.arrayInfo(INDArray arr) |
INDArray |
OpExecutioner.bitmapDecode(INDArray encoded,
INDArray target) |
INDArray |
DefaultOpExecutioner.bitmapDecode(INDArray encoded,
INDArray target) |
INDArray |
OpExecutioner.bitmapEncode(INDArray indArray,
double threshold) |
INDArray |
DefaultOpExecutioner.bitmapEncode(INDArray indArray,
double threshold) |
long |
OpExecutioner.bitmapEncode(INDArray indArray,
INDArray target,
double threshold)
This method returns number of elements affected by encoder
|
long |
DefaultOpExecutioner.bitmapEncode(INDArray indArray,
INDArray target,
double threshold) |
static void |
OpExecutionerUtil.checkForAny(INDArray z) |
static void |
OpExecutionerUtil.checkForInf(INDArray z) |
static void |
OpExecutionerUtil.checkForNaN(INDArray z) |
protected void |
DefaultOpExecutioner.checkWorkspace(String opName,
INDArray array) |
protected static String |
DefaultOpExecutioner.firstX(INDArray array,
int x) |
INDArrayStatistics |
OpExecutioner.inspectArray(INDArray array) |
INDArrayStatistics |
DefaultOpExecutioner.inspectArray(INDArray array) |
void |
OpExecutioner.scatterUpdate(ScatterUpdate.UpdateOp op,
INDArray array,
INDArray indices,
INDArray updates,
int[] axis)
Deprecated.
|
void |
DefaultOpExecutioner.scatterUpdate(ScatterUpdate.UpdateOp op,
INDArray array,
INDArray indices,
INDArray updates,
int[] axis) |
TadPack |
OpExecutioner.tadShapeInfoAndOffsets(INDArray array,
int[] dimension)
This method returns host/device tad buffers
|
TadPack |
DefaultOpExecutioner.tadShapeInfoAndOffsets(INDArray array,
int[] dimension) |
INDArray |
OpExecutioner.thresholdDecode(INDArray encoded,
INDArray target)
This method decodes thresholds array, and puts it into target array
|
INDArray |
DefaultOpExecutioner.thresholdDecode(INDArray encoded,
INDArray target) |
INDArray |
OpExecutioner.thresholdEncode(INDArray input,
double threshold)
This method encodes array as thresholds, updating input array at the same time
|
INDArray |
DefaultOpExecutioner.thresholdEncode(INDArray input,
double threshold) |
INDArray |
OpExecutioner.thresholdEncode(INDArray input,
double threshold,
Integer boundary)
This method encodes array as thresholds, updating input array at the same time
|
INDArray |
DefaultOpExecutioner.thresholdEncode(INDArray input,
double threshold,
Integer boundary) |
static void |
DefaultOpExecutioner.validateDataType(DataType expectedType,
Object op,
INDArray... operands) |
| Modifier and Type | Method and Description |
|---|---|
Map<String,INDArray> |
OpExecutioner.executeGraph(long id,
Map<String,INDArray> map,
Map<String,Integer> reverseMap) |
Map<String,INDArray> |
DefaultOpExecutioner.executeGraph(long id,
Map<String,INDArray> map,
Map<String,Integer> reverseMap) |
| Constructor and Description |
|---|
BroadcastEqualTo(INDArray x,
INDArray y,
INDArray z,
int... dimension) |
BroadcastGreaterThan(INDArray x,
INDArray y,
INDArray z,
int... dimension) |
BroadcastGreaterThanOrEqual(INDArray x,
INDArray y,
INDArray z,
int... dimension) |
BroadcastLessThan(INDArray x,
INDArray y,
INDArray z,
int... dimension) |
BroadcastLessThanOrEqual(INDArray x,
INDArray y,
INDArray z,
int... dimension) |
BroadcastNotEqual(INDArray x,
INDArray y,
INDArray z,
int... dimension) |
| Constructor and Description |
|---|
Select(INDArray[] inputs,
INDArray[] outputs) |
Select(INDArray[] inputs,
INDArray[] outputs) |
Select(INDArray[] inputs,
INDArray[] outputs,
List<Double> tArguments,
List<Integer> iArguments) |
Select(INDArray[] inputs,
INDArray[] outputs,
List<Double> tArguments,
List<Integer> iArguments) |
Where(INDArray[] inputs,
INDArray[] outputs) |
Where(INDArray[] inputs,
INDArray[] outputs) |
Where(String opName,
INDArray[] inputs,
INDArray[] outputs,
List<Double> tArguments,
List<Integer> iArguments) |
Where(String opName,
INDArray[] inputs,
INDArray[] outputs,
List<Double> tArguments,
List<Integer> iArguments) |
WhereNumpy(INDArray[] inputs,
INDArray[] outputs) |
WhereNumpy(INDArray[] inputs,
INDArray[] outputs) |
WhereNumpy(String opName,
INDArray[] inputs,
INDArray[] outputs,
List<Double> tArguments,
List<Integer> iArguments) |
WhereNumpy(String opName,
INDArray[] inputs,
INDArray[] outputs,
List<Double> tArguments,
List<Integer> iArguments) |
| Constructor and Description |
|---|
BaseGridOp(INDArray x,
INDArray y) |
FreeGridOp(INDArray x,
INDArray y) |
| Constructor and Description |
|---|
CropAndResize(INDArray image,
INDArray cropBoxes,
INDArray boxIndices,
INDArray cropOutSize,
CropAndResize.Method method,
double extrapolationValue,
INDArray output) |
ExtractImagePatches(INDArray input,
int[] kSizes,
int[] strides,
int[] rates,
boolean sameMode) |
NonMaxSuppression(INDArray boxes,
INDArray scores,
int maxOutSize,
double iouThreshold,
double scoreThreshold) |
ResizeBicubic(INDArray image,
INDArray size,
boolean alignCorners,
boolean alignPixelCenters) |
ResizeBilinear(INDArray x,
INDArray z,
int height,
int width,
boolean alignCorners,
boolean halfPixelCenters) |
| Constructor and Description |
|---|
FirstIndex(INDArray x,
Condition condition,
boolean keepDims,
int... dimension) |
FirstIndex(INDArray x,
Condition condition,
double eps,
int... dimension) |
FirstIndex(INDArray x,
Condition condition,
int... dimension) |
IAMax(INDArray x,
boolean keepDims,
int... dimensions) |
IAMax(INDArray x,
INDArray z,
int... dimensions) |
IAMax(INDArray x,
int... dimensions) |
IAMin(INDArray in,
boolean keepDims,
int... dimnesions) |
IAMin(INDArray x,
INDArray z,
int... dimensions) |
IAMin(INDArray x,
int... dimensions) |
IMax(INDArray x,
INDArray z,
int... dimensions) |
IMax(INDArray x,
int... dimensions) |
IMin(INDArray x,
INDArray z,
int... dimensions) |
IMin(INDArray x,
int... dimensions) |
LastIndex(INDArray x,
Condition condition,
boolean keepDim,
int... dimensions) |
LastIndex(INDArray x,
Condition condition,
double eps,
int... dimensions) |
LastIndex(INDArray x,
Condition condition,
int... dimensions) |
| Constructor and Description |
|---|
ExternalErrorsFunction(SameDiff sd,
List<SDVariable> inputs,
Map<String,INDArray> gradients) |
| Constructor and Description |
|---|
AvgPooling2D(INDArray input,
INDArray output,
Pooling2DConfig config) |
AvgPooling3D(SameDiff sameDiff,
INDArray arrayInput,
INDArray arrayOutput,
Pooling3DConfig config) |
BatchNorm(INDArray input,
INDArray mean,
INDArray variance,
INDArray gamma,
INDArray beta,
double epsilon,
int... axis) |
BatchNorm(SameDiff sameDiff,
SDVariable[] inputFunctions,
INDArray[] inputArrays,
INDArray[] outputArrays,
boolean inPlace,
boolean applyGamma,
boolean applyBeta,
double epsilon,
int[] axis) |
BatchNorm(SameDiff sameDiff,
SDVariable[] inputFunctions,
INDArray[] inputArrays,
INDArray[] outputArrays,
boolean inPlace,
boolean applyGamma,
boolean applyBeta,
double epsilon,
int[] axis) |
BatchNormDerivative(SameDiff sameDiff,
SDVariable[] inputFunctions,
INDArray[] inputArrays,
INDArray[] outputArrays,
boolean inPlace,
boolean applyGamma,
boolean applyBeta,
double epsilon,
int[] axis) |
BatchNormDerivative(SameDiff sameDiff,
SDVariable[] inputFunctions,
INDArray[] inputArrays,
INDArray[] outputArrays,
boolean inPlace,
boolean applyGamma,
boolean applyBeta,
double epsilon,
int[] axis) |
Col2Im(SameDiff sameDiff,
SDVariable[] inputFunctions,
INDArray[] inputArrays,
INDArray[] outputs,
Conv2DConfig conv2DConfig) |
Col2Im(SameDiff sameDiff,
SDVariable[] inputFunctions,
INDArray[] inputArrays,
INDArray[] outputs,
Conv2DConfig conv2DConfig) |
Conv1D(INDArray[] inputs,
INDArray[] outputs,
Conv1DConfig config) |
Conv1D(INDArray[] inputs,
INDArray[] outputs,
Conv1DConfig config) |
Conv1D(INDArray input,
INDArray weights,
INDArray bias,
INDArray output,
Conv1DConfig config) |
Conv1DDerivative(INDArray[] inputs,
INDArray[] outputs,
Conv1DConfig config) |
Conv1DDerivative(INDArray[] inputs,
INDArray[] outputs,
Conv1DConfig config) |
Conv1DDerivative(INDArray input,
INDArray weights,
INDArray bias,
INDArray gradOut,
INDArray output,
Conv1DConfig config) |
Conv2D(INDArray[] inputs,
INDArray[] outputs,
Conv2DConfig config) |
Conv2D(INDArray[] inputs,
INDArray[] outputs,
Conv2DConfig config) |
Conv2D(INDArray input,
INDArray weights,
INDArray bias,
INDArray output,
Conv2DConfig config) |
Conv3D(INDArray[] inputs,
INDArray[] outputs,
Conv3DConfig config) |
Conv3D(INDArray[] inputs,
INDArray[] outputs,
Conv3DConfig config) |
Conv3D(INDArray input,
INDArray weights,
INDArray bias,
INDArray output,
Conv3DConfig config) |
DeConv2D(INDArray[] inputs,
INDArray[] outputs,
DeConv2DConfig config) |
DeConv2D(INDArray[] inputs,
INDArray[] outputs,
DeConv2DConfig config) |
DeConv2D(INDArray input,
INDArray weights,
INDArray bias,
INDArray output,
DeConv2DConfig config) |
DeConv2DTF(INDArray[] inputs,
INDArray[] outputs,
DeConv2DConfig config) |
DeConv2DTF(INDArray[] inputs,
INDArray[] outputs,
DeConv2DConfig config) |
DeConv3D(INDArray[] inputs,
INDArray[] outputs,
DeConv3DConfig config) |
DeConv3D(INDArray[] inputs,
INDArray[] outputs,
DeConv3DConfig config) |
DeConv3D(INDArray input,
INDArray weights,
INDArray bias,
INDArray output,
DeConv3DConfig config) |
DepthToSpace(INDArray in,
INDArray out,
int blockSize,
String dataFormat) |
DepthwiseConv2D(INDArray[] inputs,
INDArray[] outputs,
Conv2DConfig config) |
DepthwiseConv2D(INDArray[] inputs,
INDArray[] outputs,
Conv2DConfig config) |
DepthwiseConv2D(INDArray input,
INDArray weights,
INDArray bias,
INDArray output,
Conv2DConfig config) |
Im2col(SameDiff sameDiff,
SDVariable[] inputFunctions,
INDArray[] inputArrays,
INDArray[] outputs,
Conv2DConfig conv2DConfig) |
Im2col(SameDiff sameDiff,
SDVariable[] inputFunctions,
INDArray[] inputArrays,
INDArray[] outputs,
Conv2DConfig conv2DConfig) |
LocalResponseNormalization(INDArray input,
INDArray output,
LocalResponseNormalizationConfig config) |
MaxPooling2D(INDArray input,
INDArray output,
Pooling2DConfig config) |
MaxPooling3D(SameDiff sameDiff,
INDArray arrayInput,
INDArray arrayOutput,
Pooling3DConfig config) |
MaxPoolWithArgmax(INDArray input,
INDArray output,
INDArray outArgMax,
Pooling2DConfig config) |
Pooling2D(INDArray[] inputs,
INDArray[] outputs,
Pooling2DConfig config) |
Pooling2D(INDArray[] inputs,
INDArray[] outputs,
Pooling2DConfig config) |
Pooling2D(INDArray input,
INDArray output,
Pooling2DConfig config) |
Pooling2DDerivative(INDArray input,
INDArray grad,
INDArray output,
Pooling2DConfig config) |
Pooling3D(SameDiff sameDiff,
SDVariable[] inputs,
INDArray[] inputArrays,
INDArray[] outputs,
boolean inPlace,
Pooling3DConfig pooling3DConfig,
Pooling3D.Pooling3DType type) |
Pooling3D(SameDiff sameDiff,
SDVariable[] inputs,
INDArray[] inputArrays,
INDArray[] outputs,
boolean inPlace,
Pooling3DConfig pooling3DConfig,
Pooling3D.Pooling3DType type) |
Pooling3DDerivative(SameDiff sameDiff,
SDVariable[] inputs,
INDArray[] inputArrays,
INDArray[] outputs,
boolean inPlace,
Pooling3DConfig pooling3DConfig,
Pooling3D.Pooling3DType type) |
Pooling3DDerivative(SameDiff sameDiff,
SDVariable[] inputs,
INDArray[] inputArrays,
INDArray[] outputs,
boolean inPlace,
Pooling3DConfig pooling3DConfig,
Pooling3D.Pooling3DType type) |
SConv2D(INDArray[] inputs,
INDArray[] outputs,
Conv2DConfig config) |
SConv2D(INDArray[] inputs,
INDArray[] outputs,
Conv2DConfig config) |
SConv2D(INDArray input,
INDArray depthWeights,
INDArray pointWeights,
INDArray bias,
INDArray output,
Conv2DConfig config) |
SpaceToDepth(INDArray in,
INDArray out,
int blockSize,
String dataFormat) |
| Constructor and Description |
|---|
BaseMetaOp(INDArray x,
INDArray y) |
InvertedPredicateMetaOp(INDArray x,
INDArray y) |
PostulateMetaOp(INDArray x,
INDArray y) |
PredicateMetaOp(INDArray x,
INDArray y) |
ReduceMetaOp(INDArray x,
INDArray y) |
| Constructor and Description |
|---|
CbowRound(INDArray target,
INDArray context,
INDArray lockedWords,
INDArray ngStarter,
INDArray syn0,
INDArray syn1,
INDArray syn1Neg,
INDArray expTable,
INDArray negTable,
INDArray indices,
INDArray codes,
int nsRounds,
INDArray alpha,
INDArray nextRandom,
INDArray inferenceVector,
INDArray numLabels,
boolean trainWords,
int numWorkers)
full constructor
|
CbowRound(int target,
int[] context,
int[] lockedWords,
INDArray syn0,
INDArray syn1,
INDArray expTable,
int[] indices,
byte[] codes,
double alpha,
long nextRandom,
INDArray inferenceVector,
int numLabels)
hs round
|
CbowRound(int target,
int[] context,
int[] lockedWords,
int ngStarter,
INDArray syn0,
INDArray syn1Neg,
INDArray expTable,
INDArray negTable,
int nsRounds,
double alpha,
long nextRandom,
INDArray inferenceVector,
int numLabels)
ns round
|
SkipGramRound(INDArray target,
INDArray ngStarter,
INDArray syn0,
INDArray syn1,
INDArray syn1Neg,
INDArray expTable,
INDArray negTable,
int nsRounds,
INDArray indices,
INDArray codes,
INDArray alpha,
INDArray randomValue,
INDArray inferenceVector,
boolean preciseMode,
int numWorkers)
full constructor
|
SkipGramRound(int target,
INDArray syn0,
INDArray syn1,
INDArray expTable,
int[] indices,
byte[] codes,
double alpha,
long randomValue,
INDArray inferenceVector)
sg hs round
|
SkipGramRound(int target,
int ngStarter,
INDArray syn0,
INDArray syn1Neg,
INDArray expTable,
INDArray negTable,
int nsRounds,
double alpha,
long randomValue,
INDArray inferenceVector)
sg ns round
|
| Constructor and Description |
|---|
HashCode(INDArray array) |
HashCode(INDArray array,
INDArray result) |
Mmul(INDArray x,
INDArray y,
INDArray z,
MMulTranspose mt) |
MmulBp(INDArray x,
INDArray y,
INDArray eps,
INDArray dldx,
INDArray dldy,
MMulTranspose mt) |
Moments(INDArray in,
INDArray outMean,
INDArray outStd,
int... axes) |
Moments(INDArray input,
int... axes) |
NormalizeMoments(INDArray counts,
INDArray means,
INDArray variances,
double shift) |
NormalizeMoments(INDArray counts,
INDArray ssSum,
INDArray ssSqSum,
INDArray outMean,
INDArray outVar) |
TensorMmul(INDArray x,
INDArray y,
INDArray z,
int[][] axes)
Initialize with the given
input, pairwise transform, result, and number
of elements
|
TensorMmul(INDArray x,
INDArray y,
int[][] axes) |
ZeroFraction(INDArray input) |
| Constructor and Description |
|---|
All(INDArray x) |
All(INDArray x,
int... axis) |
Any(INDArray x) |
IsInf(INDArray x) |
IsInf(INDArray x,
INDArray z) |
IsNaN(INDArray x) |
IsNaN(INDArray x,
INDArray z) |
| Constructor and Description |
|---|
BaseReductionBp(INDArray origInput,
INDArray gradAtOutput,
INDArray output,
boolean keepDims,
int... dimensions) |
BaseReductionBp(INDArray origInput1,
INDArray origInput2,
INDArray gradAtOutput,
INDArray output,
boolean keepDims,
int... dimensions) |
CumProdBp(INDArray origInput,
INDArray gradAtOutput,
INDArray output,
boolean exclusive,
boolean reverse,
int... axis) |
CumSumBp(INDArray origInput,
INDArray gradAtOutput,
INDArray output,
boolean exclusive,
boolean reverse,
int... axis) |
DotBp(INDArray origInput1,
INDArray origInput2,
INDArray gradAtOutput,
INDArray output,
boolean keepDims,
int... dimensions) |
MaxBp(INDArray origInput,
INDArray gradAtOutput,
INDArray output,
boolean keepDims,
int... dimensions) |
MeanBp(INDArray origInput,
INDArray gradAtOutput,
INDArray output,
boolean keepDims,
int... dimensions) |
MinBp(INDArray origInput,
INDArray gradAtOutput,
INDArray output,
boolean keepDims,
int... dimensions) |
Norm1Bp(INDArray origInput,
INDArray gradAtOutput,
INDArray output,
boolean keepDims,
int... dimensions) |
Norm2Bp(INDArray origInput,
INDArray gradAtOutput,
INDArray output,
boolean keepDims,
int... dimensions) |
NormMaxBp(INDArray origInput,
INDArray gradAtOutput,
INDArray output,
boolean keepDims,
int... dimensions) |
ProdBp(INDArray origInput,
INDArray gradAtOutput,
INDArray output,
boolean keepDims,
int... dimensions) |
SquaredNormBp(INDArray origInput,
INDArray gradAtOutput,
INDArray output,
boolean keepDims,
int... dimensions) |
StandardDeviationBp(INDArray origInput,
INDArray gradAtOutput,
INDArray output,
boolean biasCorrected,
boolean keepDims,
int... dimensions) |
SumBp(INDArray origInput,
INDArray gradAtOutput,
INDArray output,
boolean keepDims,
int... dimensions) |
VarianceBp(INDArray origInput,
INDArray gradAtOutput,
INDArray output,
boolean biasCorrected,
boolean keepDims,
int... dimensions) |
| Constructor and Description |
|---|
LogSumExp(INDArray x,
boolean keepDim,
int... dimensions) |
LogSumExp(INDArray x,
INDArray z,
boolean keepDim,
int... dimensions) |
LogSumExp(INDArray x,
int... dimensions) |
| Modifier and Type | Method and Description |
|---|---|
INDArray |
NormMax.noOp() |
INDArray |
Norm2.noOp() |
INDArray |
Norm1.noOp() |
| Constructor and Description |
|---|
AMean(INDArray x,
INDArray z,
int... dimensions) |
AMean(INDArray x,
int... dimensions) |
Bias(INDArray x,
int... dimensions) |
Entropy(INDArray x,
INDArray z,
int... dimensions) |
Entropy(INDArray x,
int... dimensions) |
LogEntropy(INDArray x,
INDArray z,
int... dimensions) |
LogEntropy(INDArray x,
int... dimensions) |
Mean(INDArray x,
boolean keepDims,
int... dimensions) |
Mean(INDArray x,
INDArray z,
boolean keepDims,
int... dimensions) |
Mean(INDArray x,
INDArray z,
int... dimensions) |
Mean(INDArray x,
int... dimensions) |
Norm1(INDArray x,
boolean keepDims,
int... dimensions) |
Norm1(INDArray x,
INDArray z,
int... dimensions) |
Norm1(INDArray x,
int... dimensions) |
Norm2(INDArray x,
boolean keepDims,
int... dimensions) |
Norm2(INDArray x,
INDArray z,
int... dimensions) |
Norm2(INDArray x,
int... dimensions) |
NormMax(INDArray x,
boolean keepDims,
int... dimensions) |
NormMax(INDArray x,
INDArray z,
int... dimensions) |
NormMax(INDArray x,
int... dimensions) |
ShannonEntropy(INDArray x,
INDArray z,
int... dimensions) |
ShannonEntropy(INDArray x,
int... dimensions) |
SquaredNorm(INDArray input,
INDArray output,
boolean keepDims,
int... dimensions) |
| Constructor and Description |
|---|
CountNonZero(INDArray x,
int... dimensions) |
CountZero(INDArray x,
int... dimensions) |
MatchCondition(INDArray x,
Condition condition,
int... dimensions) |
MatchCondition(INDArray x,
double eps,
Condition condition,
int... dimensions) |
| Constructor and Description |
|---|
AMax(INDArray x,
INDArray z,
int... dimensions) |
AMax(INDArray x,
int... dimensions) |
AMin(INDArray x,
INDArray z,
int... dimensions) |
AMin(INDArray x,
int... dimensions) |
ASum(INDArray x,
INDArray z,
int... dimensions) |
ASum(INDArray x,
int... dimensions) |
Max(INDArray x,
boolean keepDims,
int... axis) |
Max(INDArray x,
INDArray z,
boolean keepDims,
int... dimensions) |
Max(INDArray x,
INDArray z,
int... axis) |
Max(INDArray x,
int... axis)
Initialize with the given
input, pairwise transform, result, and number
of elements
|
Min(INDArray x,
boolean keepDims,
int... dimensions) |
Min(INDArray x,
INDArray z,
boolean keepDims,
int... dimensions) |
Min(INDArray x,
INDArray z,
int... dimensions) |
Min(INDArray x,
int... dimensions) |
Prod(INDArray x,
boolean keepDims,
int... dimensions) |
Prod(INDArray x,
INDArray z,
boolean keepDims,
int... dimensions) |
Prod(INDArray x,
INDArray z,
int... dimensions) |
Prod(INDArray x,
int... dimensions) |
Sum(INDArray x,
INDArray z,
boolean keepDims,
int... dimensions) |
Sum(INDArray x,
INDArray z,
int... dimensions) |
Sum(INDArray x,
int... dimensions) |
| Constructor and Description |
|---|
BaseReduce3Op(INDArray x,
INDArray y,
boolean allDistances,
int... dimensions) |
BaseReduce3Op(INDArray x,
INDArray y,
INDArray z) |
BaseReduce3Op(INDArray x,
INDArray y,
INDArray z,
boolean keepDims,
boolean allDistances,
int... dimensions) |
BaseReduce3Op(INDArray x,
INDArray y,
INDArray z,
boolean keepDims,
int... dimensions) |
BaseReduce3Op(INDArray x,
INDArray y,
INDArray z,
int... dimensions) |
BaseReduce3Op(INDArray x,
INDArray y,
int... dimensions) |
CosineDistance(INDArray x,
INDArray y,
boolean allDistances,
int... dimension) |
CosineDistance(INDArray x,
INDArray y,
INDArray z) |
CosineDistance(INDArray x,
INDArray y,
INDArray z,
boolean keepDims,
boolean allDistances,
int... dimensions) |
CosineDistance(INDArray x,
INDArray y,
INDArray z,
boolean allDistances,
int... dimension) |
CosineDistance(INDArray x,
INDArray y,
INDArray z,
int... dimension) |
CosineDistance(INDArray x,
INDArray y,
int... dimension) |
CosineSimilarity(INDArray x,
INDArray y,
boolean allDistances,
int... dimension) |
CosineSimilarity(INDArray x,
INDArray y,
INDArray z) |
CosineSimilarity(INDArray x,
INDArray y,
INDArray z,
boolean keepDims,
boolean allDistances,
int... dimensions) |
CosineSimilarity(INDArray x,
INDArray y,
INDArray z,
boolean allDistances,
int... dimension) |
CosineSimilarity(INDArray x,
INDArray y,
INDArray z,
int... dimensions) |
CosineSimilarity(INDArray x,
INDArray y,
int... dimensions) |
Dot(INDArray x,
INDArray y,
INDArray z) |
Dot(INDArray x,
INDArray y,
INDArray z,
boolean newFormat,
boolean keepDims,
int... dimensions) |
Dot(INDArray x,
INDArray y,
INDArray z,
int... dimensions)
Full array dot product reduction, optionally along specified dimensions.
|
Dot(INDArray x,
INDArray y,
int... dimensions) |
EqualsWithEps(INDArray x,
INDArray y,
double eps,
int... dimensions) |
EqualsWithEps(INDArray x,
INDArray y,
INDArray z) |
EqualsWithEps(INDArray x,
INDArray y,
INDArray z,
double eps,
int... dimensions) |
EuclideanDistance(INDArray x,
INDArray y,
boolean allDistances,
int... dimensions) |
EuclideanDistance(INDArray x,
INDArray y,
INDArray z) |
EuclideanDistance(INDArray x,
INDArray y,
INDArray z,
boolean keepDims,
boolean allDistances,
int... dimensions) |
EuclideanDistance(INDArray x,
INDArray y,
INDArray z,
boolean allDistances,
int... dimensions) |
EuclideanDistance(INDArray x,
INDArray y,
INDArray z,
int... dimensions) |
EuclideanDistance(INDArray x,
INDArray y,
int... dimensions) |
HammingDistance(INDArray x,
INDArray y,
boolean allDistances,
int... dimensions) |
HammingDistance(INDArray x,
INDArray y,
INDArray z) |
HammingDistance(INDArray x,
INDArray y,
INDArray z,
boolean keepDims,
boolean allDistances,
int... dimensions) |
HammingDistance(INDArray x,
INDArray y,
INDArray z,
boolean allDistances,
int... dimensions) |
HammingDistance(INDArray x,
INDArray y,
int... dimensions) |
JaccardDistance(INDArray x,
INDArray y,
boolean allDistances) |
JaccardDistance(INDArray x,
INDArray y,
INDArray z) |
JaccardDistance(INDArray x,
INDArray y,
INDArray z,
boolean keepDims,
boolean allDistances,
int... dimensions) |
JaccardDistance(INDArray x,
INDArray y,
INDArray z,
boolean allDistances,
int... dimensions) |
JaccardDistance(INDArray x,
INDArray y,
int... dimensions) |
ManhattanDistance(INDArray x,
INDArray y,
boolean allDistances,
int... dimensions) |
ManhattanDistance(INDArray x,
INDArray y,
INDArray z) |
ManhattanDistance(INDArray x,
INDArray y,
INDArray z,
boolean keepDims,
boolean allDistances,
int... dimensions) |
ManhattanDistance(INDArray x,
INDArray y,
INDArray z,
boolean allDistances,
int... dimensions) |
ManhattanDistance(INDArray x,
INDArray y,
int... dimensions) |
| Constructor and Description |
|---|
Concat(int concatDimension,
INDArray... arrays) |
ConfusionMatrix(INDArray labels,
INDArray predicted,
DataType dataType) |
ConfusionMatrix(INDArray labels,
INDArray predicted,
INDArray weights) |
ConfusionMatrix(INDArray labels,
INDArray predicted,
INDArray weights,
Integer numClasses) |
ConfusionMatrix(INDArray labels,
INDArray predicted,
INDArray weights,
Integer numClasses,
DataType dataType) |
ConfusionMatrix(INDArray labels,
INDArray predicted,
int numClasses) |
ConfusionMatrix(INDArray labels,
INDArray predicted,
Integer numClasses,
DataType dataType) |
Create(INDArray shape,
boolean initialize,
DataType dataType) |
Create(INDArray shape,
char order,
boolean initialize,
DataType dataType) |
Create(INDArray shape,
DataType dataType) |
Cross(INDArray a,
INDArray b) |
Cross(INDArray a,
INDArray b,
INDArray out) |
Diag(INDArray input) |
Diag(INDArray input,
INDArray output) |
DiagPart(INDArray in) |
DiagPart(INDArray in,
INDArray out) |
ExpandDims(INDArray[] inputs,
INDArray[] outputs) |
ExpandDims(INDArray[] inputs,
INDArray[] outputs) |
Eye(INDArray rows) |
Eye(INDArray rows,
INDArray columns) |
MergeAvg(INDArray... inputs) |
MergeMax(INDArray... inputs) |
OneHot(INDArray indices,
INDArray output,
int depth) |
OneHot(INDArray indices,
INDArray output,
int depth,
int axis,
double on,
double off) |
Permute(INDArray input,
INDArray result,
int... permuteDims) |
Repeat(INDArray[] inputs,
INDArray[] outputs,
int axis) |
Repeat(INDArray[] inputs,
INDArray[] outputs,
int axis) |
Repeat(INDArray[] inputs,
INDArray[] outputs,
List<Double> tArguments,
List<Integer> iArguments,
int axis) |
Repeat(INDArray[] inputs,
INDArray[] outputs,
List<Double> tArguments,
List<Integer> iArguments,
int axis) |
Reshape(INDArray in,
INDArray shape,
INDArray out) |
Shape(INDArray in,
INDArray out) |
SizeAt(INDArray input,
INDArray output,
int dimension) |
SizeAt(INDArray input,
int dimension) |
Stack(INDArray[] inputs,
INDArray output,
int axis) |
Stack(INDArray[] inputs,
INDArray output,
int axis) |
Tile(INDArray[] inputs,
INDArray[] outputs,
int[] axis) |
Tile(INDArray[] inputs,
INDArray[] outputs,
int[] axis) |
Tile(INDArray[] inputs,
INDArray[] outputs,
int[] axis,
boolean is_static_reps) |
Tile(INDArray[] inputs,
INDArray[] outputs,
int[] axis,
boolean is_static_reps) |
Transpose(INDArray input,
INDArray result) |
Unstack(INDArray in,
INDArray[] out,
int axis) |
Unstack(INDArray in,
INDArray[] out,
int axis) |
ZerosLike(INDArray in,
INDArray out) |
| Modifier and Type | Method and Description |
|---|---|
INDArray |
Variance.noOp() |
| Constructor and Description |
|---|
StandardDeviation(INDArray x) |
StandardDeviation(INDArray x,
boolean biasCorrected,
boolean keepDims,
int... dimension) |
StandardDeviation(INDArray x,
boolean biasCorrected,
int... dimension) |
StandardDeviation(INDArray x,
INDArray z,
boolean newFormat,
boolean keepDims,
int[] dimensions) |
StandardDeviation(INDArray x,
INDArray z,
boolean biasCorrected,
int... dimension) |
Variance(INDArray x,
boolean biasCorrected,
int... dimensions) |
Variance(INDArray x,
INDArray z,
boolean biasCorrected,
boolean keepDims,
int... dimensions) |
Variance(INDArray x,
INDArray z,
boolean biasCorrected,
int... dimensions) |
Variance(INDArray x,
int... dimension) |
| Constructor and Description |
|---|
BaseDynamicTransformOp(INDArray[] inputs,
INDArray[] outputs) |
BaseDynamicTransformOp(INDArray[] inputs,
INDArray[] outputs) |
Histogram(INDArray input,
INDArray output) |
Histogram(INDArray input,
long numBins) |
MaxOut(INDArray x) |
MaxOut(INDArray x,
INDArray z) |
Pad(INDArray in,
INDArray padding,
INDArray out,
Pad.Mode mode,
double padValue) |
ReluLayer(INDArray input,
INDArray weights,
INDArray bias) |
| Constructor and Description |
|---|
Assign(INDArray x) |
Assign(INDArray x,
INDArray z) |
IsMax(INDArray x) |
IsMax(INDArray x,
INDArray z) |
IsMax(INDArray x,
INDArray z,
int... dimensions) |
IsMax(INDArray x,
int... dimensions) |
| Constructor and Description |
|---|
BooleanNot(INDArray x) |
BooleanNot(INDArray x,
INDArray z) |
IsFinite(INDArray x) |
IsFinite(INDArray x,
INDArray z) |
IsInf(INDArray x) |
IsInf(INDArray x,
INDArray z) |
IsNaN(INDArray x) |
IsNaN(INDArray x,
INDArray z) |
MatchConditionTransform(INDArray x,
Condition condition) |
MatchConditionTransform(INDArray x,
double eps,
Condition condition) |
MatchConditionTransform(INDArray x,
INDArray z,
Condition condition) |
MatchConditionTransform(INDArray x,
INDArray z,
double eps,
Condition condition) |
MatchConditionTransform(INDArray x,
INDArray y,
INDArray z,
Condition condition) |
| Constructor and Description |
|---|
ClipByNorm(INDArray in,
double clipValue,
int... dimensions) |
ClipByNorm(INDArray in,
INDArray out,
double clipValue,
int... dimensions) |
ClipByValue(INDArray input,
double clipValueMin,
double clipValueMax) |
| Constructor and Description |
|---|
CompareAndReplace(INDArray x,
INDArray y,
Condition condition)
With this constructor, op will check each X element against given Condition, and if condition met, element Z will be set to Y value, and X otherwise
PLEASE NOTE: X will be modified inplace.
|
CompareAndReplace(INDArray x,
INDArray y,
INDArray z,
Condition condition)
With this constructor, op will check each X element against given Condition, and if condition met, element Z will be set to Y value, and X otherwise
Pseudocode:
z[i] = condition(x[i]) ?
|
CompareAndSet(INDArray x,
double set,
Condition condition)
With this constructor, op will check each X element against given Condition, and if condition met, element will be replaced with Set value
Pseudocode:
z[i] = condition(x[i]) ?
|
CompareAndSet(INDArray x,
double compare,
double set,
double eps) |
CompareAndSet(INDArray x,
double compare,
double set,
double eps,
Condition condition) |
CompareAndSet(INDArray x,
INDArray y,
Condition condition)
With this constructor, op will check each Y element against given Condition, and if condition met, element Z will be set to Y value, and X otherwise
PLEASE NOTE: X will be modified inplace.
|
CompareAndSet(INDArray x,
INDArray z,
double set,
Condition condition)
With this constructor, op will check each X element against given Condition, and if condition met, element will be replaced with Set value
Pseudocode:
z[i] = condition(x[i]) ?
|
CompareAndSet(INDArray x,
INDArray z,
double compare,
double set,
double eps)
This constructor is shortcut to epsEquals.
|
CompareAndSet(INDArray x,
INDArray y,
INDArray z,
Condition condition)
With this constructor, op will check each Y element against given Condition, and if condition met, element Z will be set to Y value, and X otherwise
Pseudocode:
z[i] = condition(y[i]) ?
|
Eps(INDArray indArray) |
Eps(INDArray x,
INDArray y,
INDArray z) |
| Constructor and Description |
|---|
Assign(INDArray[] inputs,
INDArray[] outputs) |
Assign(INDArray[] inputs,
INDArray[] outputs) |
ATan2(INDArray x,
INDArray y)
Note that the order of x and y match
Math.atan2(double, double),
and are reversed when compared to OldATan2. |
ATan2(INDArray x,
INDArray y,
INDArray z)
Note that the order of x and y match
Math.atan2(double, double),
and are reversed when compared to OldATan2. |
BitsHammingDistance(INDArray x,
INDArray y) |
BitwiseAnd(INDArray x,
INDArray y) |
BitwiseAnd(INDArray x,
INDArray y,
INDArray output) |
BitwiseOr(INDArray x,
INDArray y) |
BitwiseOr(INDArray x,
INDArray y,
INDArray output) |
BitwiseXor(INDArray x,
INDArray y) |
BitwiseXor(INDArray x,
INDArray y,
INDArray output) |
Choose(INDArray[] inputs,
Condition condition) |
Choose(INDArray[] inputs,
List<Integer> iArgs,
List<Double> tArgs,
Condition condition)
Note that iArgs (integer arguments) and tArgs(double/float arguments)
may end up being used under the following conditions:
scalar operations (if a scalar is specified the you do not need to specify an ndarray)
otherwise, if an ndarray is needed as a second input then put it in the inputs
Usually, you only need 1 input (the equivalent of the array you're trying to do indexing on)
|
Choose(String opName,
INDArray[] inputs,
Condition condition) |
Choose(String opName,
INDArray[] inputs,
INDArray[] outputs,
List<Double> tArguments,
List<Integer> iArguments) |
Choose(String opName,
INDArray[] inputs,
INDArray[] outputs,
List<Double> tArguments,
List<Integer> iArguments) |
CumProd(INDArray in,
INDArray result,
boolean exclusive,
boolean reverse,
int... axis) |
CumSum(INDArray in,
INDArray result,
boolean exclusive,
boolean reverse,
int... axis) |
CyclicRShiftBits(INDArray input,
INDArray shift) |
CyclicRShiftBits(INDArray input,
INDArray shift,
INDArray output) |
CyclicShiftBits(INDArray input,
INDArray shift) |
CyclicShiftBits(INDArray input,
INDArray shift,
INDArray output) |
Dilation2D(INDArray[] inputArrays,
INDArray[] outputs) |
Dilation2D(INDArray[] inputArrays,
INDArray[] outputs) |
DotProductAttention(INDArray queries,
INDArray keys,
INDArray values,
INDArray mask,
boolean scaled) |
DotProductAttention(INDArray queries,
INDArray keys,
INDArray values,
INDArray mask,
boolean scaled,
boolean withWeights) |
EqualTo(INDArray[] inputs,
INDArray[] outputs) |
EqualTo(INDArray[] inputs,
INDArray[] outputs) |
EqualTo(INDArray x,
INDArray y,
INDArray z) |
FakeQuantWithMinMaxArgs(INDArray x,
INDArray min,
INDArray max,
int num_bits,
boolean narrow) |
FakeQuantWithMinMaxVars(INDArray x,
INDArray min,
INDArray max,
int num_bits,
boolean narrow) |
Fill(INDArray shape,
INDArray result,
double value) |
Fill(INDArray shape,
INDArray value,
INDArray result) |
GreaterThan(INDArray[] inputs,
INDArray[] outputs) |
GreaterThan(INDArray[] inputs,
INDArray[] outputs) |
GreaterThan(INDArray x,
INDArray y,
INDArray z) |
GreaterThanOrEqual(INDArray[] inputs,
INDArray[] outputs) |
GreaterThanOrEqual(INDArray[] inputs,
INDArray[] outputs) |
GreaterThanOrEqual(INDArray x,
INDArray y,
INDArray z) |
IsNonDecreasing(INDArray input) |
IsNonDecreasing(INDArray input,
INDArray output) |
IsNumericTensor(INDArray[] inputs,
INDArray[] outputs) |
IsNumericTensor(INDArray[] inputs,
INDArray[] outputs) |
IsStrictlyIncreasing(INDArray input) |
IsStrictlyIncreasing(INDArray input,
INDArray output) |
LayerNorm(INDArray input,
INDArray gain,
boolean channelsFirst,
int... dimensions) |
LayerNorm(INDArray input,
INDArray gain,
INDArray result,
boolean channelsFirst,
int... dimensions) |
LayerNorm(INDArray input,
INDArray gain,
INDArray bias,
INDArray result,
boolean channelsFirst,
int... dimensions) |
LayerNormBp(INDArray input,
INDArray gain,
INDArray grad,
INDArray dLdx,
INDArray dLdg,
boolean channelsFirst,
int... dimensions) |
LayerNormBp(INDArray input,
INDArray gain,
INDArray bias,
INDArray grad,
INDArray dLdx,
INDArray dLdg,
INDArray dLdb,
boolean channelsFirst,
int... dimensions) |
LessThan(INDArray[] inputs,
INDArray[] outputs) |
LessThan(INDArray[] inputs,
INDArray[] outputs) |
LessThan(INDArray x,
INDArray y,
INDArray z) |
LessThanOrEqual(INDArray[] inputs,
INDArray[] outputs) |
LessThanOrEqual(INDArray[] inputs,
INDArray[] outputs) |
LessThanOrEqual(INDArray x,
INDArray y,
INDArray z) |
LogSoftMax(INDArray x) |
LogSoftMax(INDArray x,
INDArray z) |
LogSoftMax(INDArray x,
int dimension) |
MatrixDeterminant(INDArray input) |
MatrixInverse(INDArray input) |
MatrixSetDiag(INDArray in,
INDArray diag) |
Max(INDArray[] inputs,
INDArray[] outputs) |
Max(INDArray[] inputs,
INDArray[] outputs) |
Max(INDArray first,
INDArray second,
INDArray out) |
Min(INDArray[] inputs,
INDArray[] outputs) |
Min(INDArray[] inputs,
INDArray[] outputs) |
Min(INDArray first,
INDArray second,
INDArray out) |
MultiHeadDotProductAttention(INDArray queries,
INDArray keys,
INDArray values,
INDArray Wq,
INDArray Wk,
INDArray Wv,
INDArray Wo,
INDArray mask,
boolean scaled) |
MultiHeadDotProductAttention(INDArray queries,
INDArray keys,
INDArray values,
INDArray Wq,
INDArray Wk,
INDArray Wv,
INDArray Wo,
INDArray mask,
boolean scaled,
boolean withWeights) |
NotEqualTo(INDArray[] inputs,
INDArray[] outputs) |
NotEqualTo(INDArray[] inputs,
INDArray[] outputs) |
NotEqualTo(INDArray x,
INDArray y,
INDArray z) |
Pow(INDArray x,
INDArray y) |
Reverse(INDArray x)
Inplace reverse.
|
Reverse(INDArray x,
INDArray z)
Reverses whole array for compatibility with OldReverse.
|
Reverse(INDArray x,
INDArray z,
int... axis)
This constructor allows to specify axis for Reverse operation
|
Reverse(INDArray x,
int... axis)
This constructor allows to specify axis for Reverse operation
|
RShiftBits(INDArray input,
INDArray shift) |
RShiftBits(INDArray input,
INDArray shift,
INDArray output) |
ShiftBits(INDArray x,
INDArray y) |
ShiftBits(INDArray x,
INDArray y,
INDArray output) |
SoftMax(INDArray input) |
SoftMax(INDArray input,
INDArray result) |
SoftMax(INDArray input,
INDArray result,
int dimension) |
SoftMax(INDArray input,
int dimension) |
Standardize(INDArray input,
INDArray result,
int... dimensions) |
Standardize(INDArray input,
int... dimensions) |
StandardizeBp(INDArray input,
INDArray eps,
INDArray result,
int... dimensions) |
Svd(INDArray input,
boolean full_matrices,
INDArray s,
INDArray u,
INDArray v) |
ThresholdRelu(INDArray input,
INDArray output,
double cutoff) |
Trace(INDArray in) |
XwPlusB(INDArray[] inputs,
INDArray output) |
XwPlusB(INDArray[] inputs,
INDArray output) |
XwPlusB(INDArray input,
INDArray weights,
INDArray bias) |
| Constructor and Description |
|---|
RSqrt(INDArray x) |
RSqrt(INDArray x,
INDArray z) |
Sqrt(INDArray x) |
Sqrt(INDArray x,
INDArray z) |
| Constructor and Description |
|---|
BinaryMinimalRelativeError(INDArray x,
INDArray y,
double thresholdRelative,
double thresholdAbsolute) |
BinaryMinimalRelativeError(INDArray x,
INDArray y,
INDArray z,
double thresholdRelative,
double thresholdAbsolute) |
BinaryRelativeError(INDArray x,
INDArray y,
double threshold) |
BinaryRelativeError(INDArray x,
INDArray y,
INDArray z,
double threshold) |
RelativeError(INDArray x,
INDArray y) |
RelativeError(INDArray x,
INDArray y,
INDArray z) |
Set(INDArray x) |
Set(INDArray x,
INDArray z) |
Set(INDArray x,
INDArray y,
INDArray z) |
| Constructor and Description |
|---|
And(INDArray x,
INDArray y) |
And(INDArray x,
INDArray y,
INDArray z) |
And(INDArray x,
INDArray y,
INDArray z,
Number comparable) |
And(INDArray x,
INDArray y,
Number comparable) |
Not(INDArray x,
INDArray y,
INDArray z,
Number comparable) |
Or(INDArray x,
INDArray y) |
Or(INDArray x,
INDArray y,
INDArray z) |
Or(INDArray x,
INDArray y,
INDArray z,
Number comparable) |
Xor(INDArray x,
INDArray y) |
Xor(INDArray x,
INDArray y,
INDArray z) |
Xor(INDArray x,
INDArray y,
INDArray z,
Number comparable) |
| Constructor and Description |
|---|
Abs(INDArray x) |
Abs(INDArray x,
INDArray z) |
AMax(INDArray x,
INDArray y,
INDArray z) |
AMin(INDArray x,
INDArray y,
INDArray z) |
Ceil(INDArray x) |
Ceil(INDArray x,
INDArray z) |
Cube(INDArray x) |
Cube(INDArray x,
INDArray z) |
Floor(INDArray x) |
Floor(INDArray x,
INDArray z) |
Identity(INDArray x,
INDArray z) |
Max(INDArray x,
INDArray y,
INDArray z) |
Min(INDArray x,
INDArray y,
INDArray z) |
Negative(INDArray x) |
Negative(INDArray x,
INDArray z) |
OneMinus(INDArray x) |
OneMinus(INDArray x,
INDArray z) |
Reciprocal(INDArray x) |
Reciprocal(INDArray x,
INDArray z) |
Round(INDArray x) |
Round(INDArray x,
INDArray z) |
Sign(INDArray x) |
Sign(INDArray x,
INDArray z) |
Square(INDArray x) |
Square(INDArray x,
INDArray z) |
TimesOneMinus(INDArray x) |
TimesOneMinus(INDArray x,
INDArray z) |
| Constructor and Description |
|---|
BaseRandomOp(INDArray x,
INDArray y,
INDArray z) |
| Constructor and Description |
|---|
RandomStandardNormal(INDArray shape) |
RandomStandardNormal(INDArray shape,
INDArray output) |
| Constructor and Description |
|---|
DistributionUniform(INDArray shape,
INDArray out,
double min,
double max) |
RandomBernoulli(INDArray shape,
INDArray out,
double p) |
RandomExponential(INDArray shape,
INDArray out,
double lambda) |
| Modifier and Type | Method and Description |
|---|---|
INDArray |
Linspace.x() |
INDArray |
Linspace.y() |
| Modifier and Type | Method and Description |
|---|---|
void |
Linspace.setX(INDArray x) |
void |
Linspace.setY(INDArray y) |
void |
TruncatedNormalDistribution.setZ(INDArray z) |
void |
LogNormalDistribution.setZ(INDArray z) |
void |
GaussianDistribution.setZ(INDArray z) |
void |
BinomialDistribution.setZ(INDArray z) |
| Constructor and Description |
|---|
AlphaDropOut(INDArray x,
double p,
double alpha,
double alphaPrime,
double beta) |
AlphaDropOut(INDArray x,
INDArray z,
double p,
double alpha,
double alphaPrime,
double beta) |
BernoulliDistribution(INDArray z,
double prob)
This op fills Z with bernoulli trial results, so 0, or 1, depending by common probability
|
BernoulliDistribution(INDArray z,
INDArray prob)
This op fills Z with bernoulli trial results, so 0, or 1, each element will have it's own success probability defined in prob array
|
BinomialDistribution(INDArray z,
INDArray probabilities)
This op fills Z with binomial distribution over given trials with probability for each trial given as probabilities INDArray
|
BinomialDistribution(INDArray z,
int trials,
double probability)
This op fills Z with binomial distribution over given trials with single given probability for all trials
|
BinomialDistribution(INDArray z,
int trials,
INDArray probabilities)
This op fills Z with binomial distribution over given trials with probability for each trial given as probabilities INDArray
|
BinomialDistributionEx(INDArray z,
INDArray probabilities)
This op fills Z with binomial distribution over given trials with probability for each trial given as probabilities INDArray
|
BinomialDistributionEx(INDArray z,
long trials,
double probability)
This op fills Z with binomial distribution over given trials with single given probability for all trials
|
BinomialDistributionEx(INDArray z,
long trials,
INDArray probabilities)
This op fills Z with binomial distribution over given trials with probability for each trial given as probabilities INDArray
|
Choice(INDArray source,
INDArray probabilities,
INDArray z) |
DropOut(INDArray x,
double p) |
DropOut(INDArray x,
INDArray z,
double p) |
DropOutInverted(INDArray x,
double p) |
DropOutInverted(INDArray x,
INDArray z,
double p) |
GaussianDistribution(INDArray z)
This op fills Z with random values within -1.0..0..1.0
|
GaussianDistribution(INDArray z,
double stddev)
This op fills Z with random values within stddev..0..stddev
|
GaussianDistribution(INDArray z,
double mean,
double stddev)
This op fills Z with random values within stddev..mean..stddev boundaries
|
GaussianDistribution(INDArray z,
INDArray means,
double stddev) |
Linspace(INDArray z,
double from,
double to) |
Linspace(INDArray z,
double from,
double to,
double step) |
LogNormalDistribution(INDArray z)
This op fills Z with random values within -1.0..0..1.0
|
LogNormalDistribution(INDArray z,
double stddev)
This op fills Z with random values within stddev..0..stddev
|
LogNormalDistribution(INDArray z,
double mean,
double stddev)
This op fills Z with random values within stddev..mean..stddev boundaries
|
LogNormalDistribution(INDArray z,
INDArray means,
double stddev) |
ProbablisticMerge(INDArray x,
INDArray y,
double probability) |
ProbablisticMerge(INDArray x,
INDArray y,
INDArray z,
double probability) |
TruncatedNormalDistribution(INDArray z)
This op fills Z with random values within -1.0..0..1.0
|
TruncatedNormalDistribution(INDArray z,
double stddev)
This op fills Z with random values within stddev..0..stddev
|
TruncatedNormalDistribution(INDArray z,
double mean,
double stddev)
This op fills Z with random values within stddev..mean..stddev boundaries
|
TruncatedNormalDistribution(INDArray z,
INDArray means,
double stddev) |
UniformDistribution(INDArray z)
This op fills Z with random values within 0...1
|
UniformDistribution(INDArray z,
double to)
This op fills Z with random values within 0...to
|
UniformDistribution(INDArray z,
double from,
double to)
This op fills Z with random values within from...to boundaries
|
| Modifier and Type | Method and Description |
|---|---|
INDArray |
Random.nextDouble(char order,
int[] shape)
Generate a uniform number ndarray
of the specified shape and order
|
INDArray |
DefaultRandom.nextDouble(char order,
int[] shape) |
INDArray |
Random.nextDouble(char order,
long[] shape) |
INDArray |
DefaultRandom.nextDouble(char order,
long[] shape) |
INDArray |
Random.nextDouble(int[] shape)
Generate a uniform number ndarray
of the specified shape
|
INDArray |
DefaultRandom.nextDouble(int[] shape) |
INDArray |
Random.nextDouble(long[] shape) |
INDArray |
DefaultRandom.nextDouble(long[] shape) |
INDArray |
Random.nextFloat(char order,
int[] shape)
Generate a uniform number ndarray
of the specified shape
|
INDArray |
DefaultRandom.nextFloat(char order,
int[] shape) |
INDArray |
Random.nextFloat(char order,
long[] shape) |
INDArray |
DefaultRandom.nextFloat(char order,
long[] shape) |
INDArray |
Random.nextFloat(int[] shape)
Generate a uniform number ndarray
of the specified shape
|
INDArray |
DefaultRandom.nextFloat(int[] shape) |
INDArray |
Random.nextFloat(long[] shape) |
INDArray |
DefaultRandom.nextFloat(long[] shape) |
INDArray |
Random.nextGaussian(char order,
int[] shape)
Generate a gaussian number ndarray
of the specified shape and order
|
INDArray |
DefaultRandom.nextGaussian(char order,
int[] shape) |
INDArray |
Random.nextGaussian(char order,
long[] shape) |
INDArray |
DefaultRandom.nextGaussian(char order,
long[] shape) |
INDArray |
Random.nextGaussian(int[] shape)
Generate a gaussian number ndarray
of the specified shape
|
INDArray |
DefaultRandom.nextGaussian(int[] shape) |
INDArray |
Random.nextGaussian(long[] shape) |
INDArray |
DefaultRandom.nextGaussian(long[] shape) |
INDArray |
Random.nextInt(int[] shape)
Generate a random set of integers
of the specified shape.
|
INDArray |
DefaultRandom.nextInt(int[] shape) |
INDArray |
Random.nextInt(int n,
int[] shape)
Generate a random set of integers
of the specified shape.
|
INDArray |
DefaultRandom.nextInt(int n,
int[] shape) |
INDArray |
Random.nextInt(int n,
long[] shape) |
INDArray |
DefaultRandom.nextInt(int n,
long[] shape) |
INDArray |
Random.nextInt(long[] shape) |
INDArray |
DefaultRandom.nextInt(long[] shape) |
| Modifier and Type | Method and Description |
|---|---|
INDArray |
Distribution.sample(INDArray target)
Fill the target array by sampling from the distribution
|
INDArray |
BaseDistribution.sample(INDArray target) |
INDArray |
Distribution.sample(int[] shape)
Sample the given shape
|
INDArray |
BaseDistribution.sample(int[] shape) |
INDArray |
Distribution.sample(long[] shape) |
INDArray |
BaseDistribution.sample(long[] shape) |
| Modifier and Type | Method and Description |
|---|---|
INDArray |
Distribution.sample(INDArray target)
Fill the target array by sampling from the distribution
|
INDArray |
BaseDistribution.sample(INDArray target) |
| Modifier and Type | Method and Description |
|---|---|
Distribution |
DistributionFactory.createBinomial(int n,
INDArray p)
Create a distribution
|
Distribution |
DefaultDistributionFactory.createBinomial(int n,
INDArray p) |
Distribution |
DistributionFactory.createNormal(INDArray mean,
double std)
Create a normal distribution
with the given mean and std
|
Distribution |
DefaultDistributionFactory.createNormal(INDArray mean,
double std) |
| Modifier and Type | Method and Description |
|---|---|
INDArray |
UniformDistribution.sample(INDArray ret) |
INDArray |
TruncatedNormalDistribution.sample(INDArray ret) |
INDArray |
OrthogonalDistribution.sample(INDArray target) |
INDArray |
NormalDistribution.sample(INDArray ret) |
INDArray |
LogNormalDistribution.sample(INDArray ret) |
INDArray |
ConstantDistribution.sample(INDArray target) |
INDArray |
BinomialDistribution.sample(INDArray ret) |
INDArray |
UniformDistribution.sample(int[] shape) |
INDArray |
TruncatedNormalDistribution.sample(int[] shape) |
INDArray |
OrthogonalDistribution.sample(int[] shape) |
INDArray |
NormalDistribution.sample(int[] shape) |
INDArray |
LogNormalDistribution.sample(int[] shape) |
INDArray |
ConstantDistribution.sample(int[] shape) |
INDArray |
BinomialDistribution.sample(int[] shape) |
INDArray |
OrthogonalDistribution.sample(long[] shape) |
| Modifier and Type | Method and Description |
|---|---|
INDArray |
UniformDistribution.sample(INDArray ret) |
INDArray |
TruncatedNormalDistribution.sample(INDArray ret) |
INDArray |
OrthogonalDistribution.sample(INDArray target) |
INDArray |
NormalDistribution.sample(INDArray ret) |
INDArray |
LogNormalDistribution.sample(INDArray ret) |
INDArray |
ConstantDistribution.sample(INDArray target) |
INDArray |
BinomialDistribution.sample(INDArray ret) |
| Constructor and Description |
|---|
BinomialDistribution(int n,
INDArray p) |
LogNormalDistribution(double standardDeviation,
INDArray means) |
LogNormalDistribution(INDArray mean,
double std) |
LogNormalDistribution(Random rng,
double standardDeviation,
INDArray means) |
NormalDistribution(double standardDeviation,
INDArray means) |
NormalDistribution(INDArray mean,
double std) |
NormalDistribution(Random rng,
double standardDeviation,
INDArray means) |
TruncatedNormalDistribution(double standardDeviation,
INDArray means) |
TruncatedNormalDistribution(INDArray mean,
double std) |
TruncatedNormalDistribution(Random rng,
double standardDeviation,
INDArray means) |
| Modifier and Type | Method and Description |
|---|---|
static INDArray |
Shape.ndArrayDimFromInt(int... dimensions)
Create an INDArray to represent the (possibly null) int[] dimensions.
|
static INDArray |
Shape.newShapeNoCopy(INDArray arr,
int[] newShape,
boolean isFOrder) |
static INDArray |
Shape.newShapeNoCopy(INDArray arr,
long[] newShape,
boolean isFOrder)
A port of numpy's reshaping algorithm that leverages
no copy where possible and returns
null if the reshape
couldn't happen without copying
|
static INDArray |
Shape.toMmulCompatible(INDArray input)
This method is used in DL4J LSTM implementation
|
static INDArray |
Shape.toOffsetZero(INDArray arr)
Create a copy of the matrix
where the new offset is zero
|
static INDArray |
Shape.toOffsetZeroCopy(INDArray arr)
Create a copy of the ndarray where the new offset is zero
|
static INDArray |
Shape.toOffsetZeroCopy(INDArray arr,
char order)
Create a copy of the ndarray where the new offset is zero, and has specified order
|
static INDArray |
Shape.toOffsetZeroCopyAnyOrder(INDArray arr)
Create a copy of the ndarray where the new offset is zero.
|
| Modifier and Type | Method and Description |
|---|---|
static void |
Shape.assertBroadcastable(INDArray x,
INDArray y) |
static void |
Shape.assertBroadcastable(String op,
INDArray first,
INDArray second,
INDArray result)
Assert that the broadcast operation
result = first.op(second) is valid, given the
shapes of first, second, and result. |
static double |
Shape.getDouble(INDArray arr,
int[] indices)
Get a double based on the array and given indices
|
static double |
Shape.getDouble(INDArray arr,
long... indices) |
static long |
Shape.getLong(INDArray arr,
long... indices) |
static long[] |
Shape.getMaxShape(INDArray... inputs)
Return the shape of the largest length array
based on the input
|
static char |
Shape.getOrder(INDArray arr)
Infer the order for the ndarray based on the
array's strides
|
static boolean |
Shape.hasDefaultStridesForShape(INDArray input) |
static long[] |
Shape.ind2sub(INDArray arr,
long index)
Convert a linear index to
the equivalent nd index based on the shape of the specified ndarray.
|
static long[] |
Shape.ind2subC(INDArray arr,
long index)
Convert a linear index to
the equivalent nd index based on the shape of the specified ndarray.
|
static boolean |
Shape.isContiguousInBuffer(INDArray in)
Are the elements in the buffer contiguous for this NDArray?
|
static void |
Shape.iterate(INDArray arr,
CoordinateFunction coordinateFunction)
Iterate over 2
coordinate spaces given 2 arrays
|
static void |
Shape.iterate(INDArray arr,
INDArray arr2,
CoordinateFunction coordinateFunction)
Iterate over 2
coordinate spaces given 2 arrays
|
static INDArray |
Shape.newShapeNoCopy(INDArray arr,
int[] newShape,
boolean isFOrder) |
static INDArray |
Shape.newShapeNoCopy(INDArray arr,
long[] newShape,
boolean isFOrder)
A port of numpy's reshaping algorithm that leverages
no copy where possible and returns
null if the reshape
couldn't happen without copying
|
static long[] |
Shape.reductionShape(INDArray x,
int[] dimension,
boolean newFormat,
boolean keepDims)
Calculate the shape of the returned array, for a reduction along dimension
|
static String |
Shape.shapeToString(INDArray arr)
Prints the shape
for this shape information
|
static String |
Shape.shapeToStringShort(INDArray arr) |
static boolean |
Shape.strideDescendingCAscendingF(INDArray array)
Check if strides are in order suitable for non-strided mmul etc.
|
static INDArray |
Shape.toMmulCompatible(INDArray input)
This method is used in DL4J LSTM implementation
|
static INDArray |
Shape.toOffsetZero(INDArray arr)
Create a copy of the matrix
where the new offset is zero
|
static INDArray |
Shape.toOffsetZeroCopy(INDArray arr)
Create a copy of the ndarray where the new offset is zero
|
static INDArray |
Shape.toOffsetZeroCopy(INDArray arr,
char order)
Create a copy of the ndarray where the new offset is zero, and has specified order
|
static INDArray |
Shape.toOffsetZeroCopyAnyOrder(INDArray arr)
Create a copy of the ndarray where the new offset is zero.
|
| Modifier and Type | Method and Description |
|---|---|
Pair<DataBuffer,DataBuffer> |
TADManager.getTADOnlyShapeInfo(INDArray array,
int... dimension)
This method returns TAD shapeInfo and all offsets
for specified tensor and dimensions.
|
| Constructor and Description |
|---|
TadDescriptor(INDArray array,
int[] dimension)
Pass in an ndarray to get the databuffer
and the appropriate dimensions
|
| Modifier and Type | Method and Description |
|---|---|
static INDArray |
CheckUtil.convertFromApacheMatrix(org.apache.commons.math3.linear.RealMatrix matrix,
DataType dataType) |
| Modifier and Type | Method and Description |
|---|---|
static List<Pair<INDArray,String>> |
NDArrayCreationUtil.get3dPermutedWithShape(int seed,
int[] shape,
DataType dataType) |
static List<Pair<INDArray,String>> |
NDArrayCreationUtil.get3dPermutedWithShape(long seed,
long[] shape,
DataType dataType) |
static List<Pair<INDArray,String>> |
NDArrayCreationUtil.get3dReshapedWithShape(int seed,
int[] shape,
DataType dataType) |
static List<Pair<INDArray,String>> |
NDArrayCreationUtil.get3dReshapedWithShape(long seed,
long[] shape,
DataType dataType) |
static List<Pair<INDArray,String>> |
NDArrayCreationUtil.get3dSubArraysWithShape(int seed,
int[] shape,
DataType dataType) |
static List<Pair<INDArray,String>> |
NDArrayCreationUtil.get3dSubArraysWithShape(long seed,
long[] shape,
DataType dataType) |
static List<Pair<INDArray,String>> |
NDArrayCreationUtil.get3dTensorAlongDimensionWithShape(int seed,
int[] shape,
DataType dataType) |
static List<Pair<INDArray,String>> |
NDArrayCreationUtil.get3dTensorAlongDimensionWithShape(long seed,
long[] shape,
DataType dataType) |
static List<Pair<INDArray,String>> |
NDArrayCreationUtil.get4dPermutedWithShape(int seed,
int[] shape,
DataType dataType) |
static List<Pair<INDArray,String>> |
NDArrayCreationUtil.get4dReshapedWithShape(int seed,
int[] shape,
DataType dataType) |
static List<Pair<INDArray,String>> |
NDArrayCreationUtil.get4dSubArraysWithShape(int seed,
int[] shape,
DataType dataType) |
static List<Pair<INDArray,String>> |
NDArrayCreationUtil.get4dTensorAlongDimensionWithShape(int seed,
int[] shape,
DataType dataType) |
static List<Pair<INDArray,String>> |
NDArrayCreationUtil.get5dPermutedWithShape(int seed,
int[] shape,
DataType dataType) |
static List<Pair<INDArray,String>> |
NDArrayCreationUtil.get5dReshapedWithShape(int seed,
int[] shape,
DataType dataType) |
static List<Pair<INDArray,String>> |
NDArrayCreationUtil.get5dSubArraysWithShape(int seed,
int[] shape,
DataType dataType) |
static List<Pair<INDArray,String>> |
NDArrayCreationUtil.get5dTensorAlongDimensionWithShape(int seed,
int[] shape,
DataType dataType) |
static List<Pair<INDArray,String>> |
NDArrayCreationUtil.get6dPermutedWithShape(int seed,
int[] shape,
DataType dataType) |
static List<Pair<INDArray,String>> |
NDArrayCreationUtil.get6dReshapedWithShape(int seed,
int[] shape,
DataType dataType) |
static List<Pair<INDArray,String>> |
NDArrayCreationUtil.get6dSubArraysWithShape(int seed,
int[] shape,
DataType dataType) |
static List<Pair<INDArray,String>> |
NDArrayCreationUtil.getAll3dTestArraysWithShape(int seed,
int[] shape,
DataType dataType) |
static List<Pair<INDArray,String>> |
NDArrayCreationUtil.getAll3dTestArraysWithShape(long seed,
long[] shape,
DataType dataType) |
static List<Pair<INDArray,String>> |
NDArrayCreationUtil.getAll4dTestArraysWithShape(int seed,
int[] shape,
DataType dataType) |
static List<Pair<INDArray,String>> |
NDArrayCreationUtil.getAll4dTestArraysWithShape(int seed,
long[] shape,
DataType dataType) |
static List<Pair<INDArray,String>> |
NDArrayCreationUtil.getAll5dTestArraysWithShape(int seed,
int[] shape,
DataType dataType) |
static List<Pair<INDArray,String>> |
NDArrayCreationUtil.getAll6dTestArraysWithShape(int seed,
int[] shape,
DataType dataType) |
static List<Pair<INDArray,String>> |
NDArrayCreationUtil.getAllTestMatricesWithShape(char ordering,
int rows,
int cols,
int seed,
DataType dataType)
Get an array of INDArrays (2d) all with the specified shape.
|
static List<Pair<INDArray,String>> |
NDArrayCreationUtil.getAllTestMatricesWithShape(long rows,
long cols,
long seed,
DataType dataType)
Get an array of INDArrays (2d) all with the specified shape.
|
static Pair<INDArray,String> |
NDArrayCreationUtil.getPermutedWithShape(char ordering,
long rows,
long cols,
long seed,
DataType dataType) |
static Pair<INDArray,String> |
NDArrayCreationUtil.getPermutedWithShape(long rows,
long cols,
long seed,
DataType dataType) |
static Pair<INDArray,String> |
NDArrayCreationUtil.getReshapedWithShape(char ordering,
long rows,
long cols,
long seed,
DataType dataType) |
static Pair<INDArray,String> |
NDArrayCreationUtil.getReshapedWithShape(long rows,
long cols,
long seed,
DataType dataType) |
static List<Pair<INDArray,String>> |
NDArrayCreationUtil.getSubMatricesWithShape(char ordering,
long rows,
long cols,
long seed,
DataType dataType) |
static List<Pair<INDArray,String>> |
NDArrayCreationUtil.getSubMatricesWithShape(long rows,
long cols,
long seed,
DataType dataType) |
static List<Pair<INDArray,String>> |
NDArrayCreationUtil.getTensorAlongDimensionMatricesWithShape(char ordering,
long rows,
long cols,
long seed,
DataType dataType) |
static List<Pair<INDArray,String>> |
NDArrayCreationUtil.getTensorAlongDimensionMatricesWithShape(long rows,
long cols,
long seed,
DataType dataType) |
static List<Pair<INDArray,String>> |
NDArrayCreationUtil.getTestMatricesWithVaryingShapes(int rank,
char order,
DataType dataType)
Test utility to sweep shapes given a rank
Given a rank will generate random test matrices that will cover all cases of a shape with a '1' anywhere in the shape
as well a shape with random ints that are not 0 or 1
eg. rank 2: 1,1; 1,2; 2,1; 2,2; 3,4
Motivated by TADs that often hit bugs when a "1" occurs as the size of a dimension
|
static Pair<INDArray,String> |
NDArrayCreationUtil.getTransposedMatrixWithShape(char ordering,
int rows,
int cols,
int seed,
DataType dataType) |
static Pair<INDArray,String> |
NDArrayCreationUtil.getTransposedMatrixWithShape(long rows,
long cols,
long seed,
DataType dataType) |
| Modifier and Type | Method and Description |
|---|---|
static boolean |
CheckUtil.checkAdd(INDArray first,
INDArray second,
double maxRelativeDifference,
double minAbsDifference)
Same as checkMmul, but for matrix addition
|
static boolean |
CheckUtil.checkDivManually(INDArray first,
INDArray second,
double maxRelativeDifference,
double minAbsDifference) |
static boolean |
CheckUtil.checkEntries(INDArray expected,
INDArray actual,
double maxRelativeDifference,
double minAbsDifference) |
static boolean |
CheckUtil.checkEntries(org.apache.commons.math3.linear.RealMatrix rmResult,
INDArray result,
double maxRelativeDifference,
double minAbsDifference) |
static boolean |
CheckUtil.checkGemm(INDArray a,
INDArray b,
INDArray c,
boolean transposeA,
boolean transposeB,
double alpha,
double beta,
double maxRelativeDifference,
double minAbsDifference) |
static boolean |
CheckUtil.checkMmul(INDArray first,
INDArray second,
double maxRelativeDifference,
double minAbsDifference)
Check first.mmul(second) using Apache commons math mmul.
|
static boolean |
CheckUtil.checkMulManually(INDArray first,
INDArray second,
double maxRelativeDifference,
double minAbsDifference) |
static boolean |
CheckUtil.checkSubtract(INDArray first,
INDArray second,
double maxRelativeDifference,
double minAbsDifference)
Same as checkMmul, but for matrix subtraction
|
static org.apache.commons.math3.linear.RealMatrix |
CheckUtil.convertToApacheMatrix(INDArray matrix) |
static void |
CheckUtil.printFailureDetails(INDArray first,
INDArray second,
INDArray expected,
INDArray actual,
INDArray onCopies,
String op) |
static void |
CheckUtil.printFailureDetails(INDArray first,
INDArray second,
org.apache.commons.math3.linear.RealMatrix expected,
INDArray actual,
INDArray onCopies,
String op) |
static void |
CheckUtil.printGemmFailureDetails(INDArray a,
INDArray b,
INDArray c,
boolean transposeA,
boolean transposeB,
double alpha,
double beta,
org.apache.commons.math3.linear.RealMatrix expected,
INDArray actual,
INDArray onCopies) |
static void |
CheckUtil.printMatrixFullPrecision(INDArray matrix) |
static void |
CheckUtil.printNDArrayHeader(INDArray array) |
| Modifier and Type | Method and Description |
|---|---|
INDArray |
NDArrayCompressor.compress(double[] data)
This method creates compressed INDArray from Java double array, skipping usual INDArray instantiation routines
Please note: This method compresses input data as vector
|
INDArray |
BasicNDArrayCompressor.compress(double[] array)
This method returns compressed INDArray instance which contains JVM array passed in
|
INDArray |
NDArrayCompressor.compress(double[] data,
int[] shape,
char order)
This method creates compressed INDArray from Java double array, skipping usual INDArray instantiation routines
|
INDArray |
NDArrayCompressor.compress(float[] data)
This method creates compressed INDArray from Java float array, skipping usual INDArray instantiation routines
Please note: This method compresses input data as vector
|
INDArray |
BasicNDArrayCompressor.compress(float[] array)
This method returns compressed INDArray instance which contains JVM array passed in
|
INDArray |
NDArrayCompressor.compress(float[] data,
int[] shape,
char order)
This method creates compressed INDArray from Java float array, skipping usual INDArray instantiation routines
|
INDArray |
NDArrayCompressor.compress(INDArray array)
This method returns compressed copy of referenced array
|
INDArray |
BasicNDArrayCompressor.compress(INDArray array) |
INDArray |
BasicNDArrayCompressor.compress(INDArray array,
String algorithm)
Returns a compressed version of the
given ndarray
|
INDArray |
NDArrayCompressor.decompress(INDArray array)
This method returns
decompressed copy of referenced array
|
INDArray |
BasicNDArrayCompressor.decompress(INDArray array) |
INDArray |
AbstractStorage.get(T key)
Get object from the storage, by key
|
| Modifier and Type | Method and Description |
|---|---|
void |
BasicNDArrayCompressor.autoDecompress(INDArray... arrays)
Decompress several ndarrays
|
void |
BasicNDArrayCompressor.autoDecompress(INDArray array) |
INDArray |
NDArrayCompressor.compress(INDArray array)
This method returns compressed copy of referenced array
|
INDArray |
BasicNDArrayCompressor.compress(INDArray array) |
INDArray |
BasicNDArrayCompressor.compress(INDArray array,
String algorithm)
Returns a compressed version of the
given ndarray
|
void |
NDArrayCompressor.compressi(INDArray array)
Inplace compression of INDArray
|
void |
BasicNDArrayCompressor.compressi(INDArray array)
In place compression of the passed in ndarray
with the default compression algorithm
|
void |
BasicNDArrayCompressor.compressi(INDArray array,
String algorithm)
In place Compress the given ndarray
with the given algorithm
|
INDArray |
NDArrayCompressor.decompress(INDArray array)
This method returns
decompressed copy of referenced array
|
INDArray |
BasicNDArrayCompressor.decompress(INDArray array) |
void |
NDArrayCompressor.decompressi(INDArray array)
Inplace decompression of INDArray
|
void |
BasicNDArrayCompressor.decompressi(INDArray array)
in place decompression of the given
ndarray.
|
void |
AbstractStorage.store(T key,
INDArray object)
Store object into storage
|
boolean |
AbstractStorage.storeIfAbsent(T key,
INDArray object)
Store object into storage, if it doesn't exist
|
| Modifier and Type | Method and Description |
|---|---|
static INDArray |
Convolution.col2im(INDArray col,
INDArray z,
int sH,
int sW,
int pH,
int pW,
int kH,
int kW,
int dH,
int dW) |
static INDArray |
OldConvolution.col2im(INDArray col,
int[] stride,
int[] padding,
int height,
int width) |
static INDArray |
Convolution.col2im(INDArray col,
int[] stride,
int[] padding,
int height,
int width) |
static INDArray |
OldConvolution.col2im(INDArray col,
int sy,
int sx,
int ph,
int pw,
int h,
int w)
Rearrange matrix
columns into blocks
|
static INDArray |
Convolution.col2im(INDArray col,
int sH,
int sW,
int ph,
int pW,
int kH,
int kW)
Rearrange matrix
columns into blocks
|
INDArray |
ConvolutionInstance.conv2d(INDArray input,
INDArray kernel,
Convolution.Type type)
2d convolution (aka the last 2 dimensions
|
static INDArray |
Convolution.conv2d(INDArray input,
INDArray kernel,
Convolution.Type type)
2d convolution (aka the last 2 dimensions
|
INDArray |
BaseConvolution.conv2d(INDArray input,
INDArray kernel,
Convolution.Type type)
2d convolution (aka the last 2 dimensions
|
INDArray |
ConvolutionInstance.convn(INDArray input,
INDArray kernel,
Convolution.Type type)
ND Convolution
|
static INDArray |
Convolution.convn(INDArray input,
INDArray kernel,
Convolution.Type type)
ND Convolution
|
INDArray |
BaseConvolution.convn(INDArray input,
INDArray kernel,
Convolution.Type type)
ND Convolution
|
INDArray |
DefaultConvolutionInstance.convn(INDArray input,
INDArray kernel,
Convolution.Type type,
int[] axes)
ND Convolution
|
INDArray |
ConvolutionInstance.convn(INDArray input,
INDArray kernel,
Convolution.Type type,
int[] axes)
ND Convolution
|
static INDArray |
Convolution.convn(INDArray input,
INDArray kernel,
Convolution.Type type,
int[] axes)
ND Convolution
|
static INDArray |
OldConvolution.im2col(INDArray img,
int[] kernel,
int[] stride,
int[] padding) |
static INDArray |
Convolution.im2col(INDArray img,
int[] kernel,
int[] stride,
int[] padding) |
static INDArray |
Convolution.im2col(INDArray img,
int kh,
int kw,
int sy,
int sx,
int ph,
int pw,
boolean isSameMode)
Implement column formatted images
|
static INDArray |
Convolution.im2col(INDArray img,
int kh,
int kw,
int sy,
int sx,
int ph,
int pw,
boolean isSameMode,
INDArray out) |
static INDArray |
OldConvolution.im2col(INDArray img,
int kh,
int kw,
int sy,
int sx,
int ph,
int pw,
int pval,
boolean coverAll)
Implement column formatted images
|
static INDArray |
Convolution.im2col(INDArray img,
int kh,
int kw,
int sy,
int sx,
int ph,
int pw,
int pval,
boolean isSameMode)
Implement column formatted images
|
static INDArray |
Convolution.im2col(INDArray img,
int kh,
int kw,
int sy,
int sx,
int ph,
int pw,
int dh,
int dw,
boolean isSameMode) |
static INDArray |
Convolution.im2col(INDArray img,
int kh,
int kw,
int sy,
int sx,
int ph,
int pw,
int dH,
int dW,
boolean isSameMode,
INDArray out) |
static INDArray |
Convolution.pooling2D(INDArray img,
int kh,
int kw,
int sy,
int sx,
int ph,
int pw,
int dh,
int dw,
boolean isSameMode,
Pooling2D.Pooling2DType type,
Pooling2D.Divisor divisor,
double extra,
int virtualHeight,
int virtualWidth,
INDArray out)
Pooling 2d implementation
|
| Modifier and Type | Method and Description |
|---|---|
static INDArray |
Convolution.col2im(INDArray col,
INDArray z,
int sH,
int sW,
int pH,
int pW,
int kH,
int kW,
int dH,
int dW) |
static INDArray |
OldConvolution.col2im(INDArray col,
int[] stride,
int[] padding,
int height,
int width) |
static INDArray |
Convolution.col2im(INDArray col,
int[] stride,
int[] padding,
int height,
int width) |
static INDArray |
OldConvolution.col2im(INDArray col,
int sy,
int sx,
int ph,
int pw,
int h,
int w)
Rearrange matrix
columns into blocks
|
static INDArray |
Convolution.col2im(INDArray col,
int sH,
int sW,
int ph,
int pW,
int kH,
int kW)
Rearrange matrix
columns into blocks
|
INDArray |
ConvolutionInstance.conv2d(INDArray input,
INDArray kernel,
Convolution.Type type)
2d convolution (aka the last 2 dimensions
|
static INDArray |
Convolution.conv2d(INDArray input,
INDArray kernel,
Convolution.Type type)
2d convolution (aka the last 2 dimensions
|
INDArray |
BaseConvolution.conv2d(INDArray input,
INDArray kernel,
Convolution.Type type)
2d convolution (aka the last 2 dimensions
|
INDArray |
ConvolutionInstance.convn(INDArray input,
INDArray kernel,
Convolution.Type type)
ND Convolution
|
static INDArray |
Convolution.convn(INDArray input,
INDArray kernel,
Convolution.Type type)
ND Convolution
|
INDArray |
BaseConvolution.convn(INDArray input,
INDArray kernel,
Convolution.Type type)
ND Convolution
|
INDArray |
DefaultConvolutionInstance.convn(INDArray input,
INDArray kernel,
Convolution.Type type,
int[] axes)
ND Convolution
|
INDArray |
ConvolutionInstance.convn(INDArray input,
INDArray kernel,
Convolution.Type type,
int[] axes)
ND Convolution
|
static INDArray |
Convolution.convn(INDArray input,
INDArray kernel,
Convolution.Type type,
int[] axes)
ND Convolution
|
static INDArray |
OldConvolution.im2col(INDArray img,
int[] kernel,
int[] stride,
int[] padding) |
static INDArray |
Convolution.im2col(INDArray img,
int[] kernel,
int[] stride,
int[] padding) |
static INDArray |
Convolution.im2col(INDArray img,
int kh,
int kw,
int sy,
int sx,
int ph,
int pw,
boolean isSameMode)
Implement column formatted images
|
static INDArray |
Convolution.im2col(INDArray img,
int kh,
int kw,
int sy,
int sx,
int ph,
int pw,
boolean isSameMode,
INDArray out) |
static INDArray |
OldConvolution.im2col(INDArray img,
int kh,
int kw,
int sy,
int sx,
int ph,
int pw,
int pval,
boolean coverAll)
Implement column formatted images
|
static INDArray |
Convolution.im2col(INDArray img,
int kh,
int kw,
int sy,
int sx,
int ph,
int pw,
int pval,
boolean isSameMode)
Implement column formatted images
|
static INDArray |
Convolution.im2col(INDArray img,
int kh,
int kw,
int sy,
int sx,
int ph,
int pw,
int dh,
int dw,
boolean isSameMode) |
static INDArray |
Convolution.im2col(INDArray img,
int kh,
int kw,
int sy,
int sx,
int ph,
int pw,
int dH,
int dW,
boolean isSameMode,
INDArray out) |
static INDArray |
Convolution.pooling2D(INDArray img,
int kh,
int kw,
int sy,
int sx,
int ph,
int pw,
int dh,
int dw,
boolean isSameMode,
Pooling2D.Pooling2DType type,
Pooling2D.Divisor divisor,
double extra,
int virtualHeight,
int virtualWidth,
INDArray out)
Pooling 2d implementation
|
| Modifier and Type | Class and Description |
|---|---|
class |
NDArray
NDArray: (think numpy)
A few things of note.
|
| Modifier and Type | Method and Description |
|---|---|
INDArray |
CpuNDArrayFactory.accumulate(INDArray target,
INDArray... arrays) |
INDArray |
CpuNDArrayFactory.average(Collection<INDArray> arrays) |
INDArray |
CpuNDArrayFactory.average(INDArray[] arrays) |
INDArray |
CpuNDArrayFactory.average(INDArray target,
Collection<INDArray> arrays)
This method averages input arrays, and returns averaged array
|
INDArray |
CpuNDArrayFactory.average(INDArray target,
INDArray[] arrays)
This method averages input arrays, and returns averaged array
|
INDArray |
CpuNDArrayFactory.concat(int dimension,
INDArray... toConcat)
concatenate ndarrays along a dimension
|
INDArray |
CpuNDArrayFactory.convertDataEx(DataTypeEx typeSrc,
INDArray source,
DataTypeEx typeDst)
This method converts Single/Double precision databuffer to Half-precision databuffer
|
INDArray |
CpuNDArrayFactory.create(boolean[] data,
long[] shape,
long[] stride,
char order,
DataType dataType,
MemoryWorkspace workspace) |
INDArray |
CpuNDArrayFactory.create(boolean[] data,
long[] shape,
long[] stride,
DataType dataType,
MemoryWorkspace workspace) |
INDArray |
CpuNDArrayFactory.create(byte[] data,
long[] shape,
long[] stride,
char order,
DataType dataType,
MemoryWorkspace workspace) |
INDArray |
CpuNDArrayFactory.create(byte[] data,
long[] shape,
long[] stride,
DataType dataType,
MemoryWorkspace workspace) |
INDArray |
CpuNDArrayFactory.create(Collection<String> strings,
long[] shape,
char order) |
INDArray |
CpuNDArrayFactory.create(DataBuffer data) |
INDArray |
CpuNDArrayFactory.create(DataBuffer data,
int[] shape) |
INDArray |
CpuNDArrayFactory.create(DataBuffer data,
int[] shape,
int[] stride,
long offset) |
INDArray |
CpuNDArrayFactory.create(DataBuffer data,
int[] newShape,
int[] newStride,
long offset,
char ordering) |
INDArray |
CpuNDArrayFactory.create(DataBuffer buffer,
int[] shape,
long offset) |
INDArray |
CpuNDArrayFactory.create(DataBuffer data,
long[] shape) |
INDArray |
CpuNDArrayFactory.create(DataBuffer data,
long[] shape,
long[] stride,
long offset) |
INDArray |
CpuNDArrayFactory.create(DataBuffer data,
long[] shape,
long[] stride,
long offset,
char ordering) |
INDArray |
CpuNDArrayFactory.create(DataBuffer data,
long[] shape,
long[] stride,
long offset,
char ordering,
DataType dataType) |
INDArray |
CpuNDArrayFactory.create(DataBuffer data,
long[] shape,
long[] stride,
long offset,
long ews,
char ordering) |
INDArray |
CpuNDArrayFactory.create(DataBuffer data,
long rows,
long columns,
int[] stride,
long offset) |
INDArray |
CpuNDArrayFactory.create(DataType dataType,
long[] shape,
char ordering,
MemoryWorkspace workspace) |
INDArray |
CpuNDArrayFactory.create(DataType dataType,
long[] shape,
long[] strides,
char ordering,
MemoryWorkspace workspace) |
INDArray |
CpuNDArrayFactory.create(double[][] data)
Create an ndarray with the given data layout
|
INDArray |
CpuNDArrayFactory.create(double[][] data,
char ordering) |
INDArray |
CpuNDArrayFactory.create(double[] data,
int[] shape,
char ordering) |
INDArray |
CpuNDArrayFactory.create(double[] data,
int[] shape,
int[] stride,
long offset)
Creates an ndarray with the specified shape
|
INDArray |
CpuNDArrayFactory.create(double[] data,
int[] shape,
int[] stride,
long offset,
char ordering) |
INDArray |
CpuNDArrayFactory.create(double[] data,
int[] shape,
long offset) |
INDArray |
CpuNDArrayFactory.create(double[] data,
long[] shape,
char ordering) |
INDArray |
CpuNDArrayFactory.create(double[] data,
long[] shape,
long[] stride,
char order,
DataType dataType,
MemoryWorkspace workspace) |
INDArray |
CpuNDArrayFactory.create(double[] data,
long[] shape,
long[] stride,
DataType dataType,
MemoryWorkspace workspace) |
INDArray |
CpuNDArrayFactory.create(double[] data,
long[] shape,
long[] stride,
long offset) |
INDArray |
CpuNDArrayFactory.create(double[] data,
long[] shape,
long[] stride,
long offset,
char ordering) |
INDArray |
CpuNDArrayFactory.create(double[] data,
long[] shape,
long offset,
Character order) |
INDArray |
CpuNDArrayFactory.create(float[][] floats) |
INDArray |
CpuNDArrayFactory.create(float[][] data,
char ordering) |
INDArray |
CpuNDArrayFactory.create(float[] data,
int[] shape,
int[] stride,
long offset)
Creates an ndarray with the specified shape
|
INDArray |
CpuNDArrayFactory.create(float[] data,
int[] shape,
int[] stride,
long offset,
char ordering) |
INDArray |
CpuNDArrayFactory.create(float[] data,
int[] shape,
long offset) |
INDArray |
CpuNDArrayFactory.create(float[] data,
int[] shape,
long offset,
Character order) |
INDArray |
CpuNDArrayFactory.create(float[] data,
long[] shape,
char ordering) |
INDArray |
CpuNDArrayFactory.create(float[] data,
long[] shape,
long[] stride,
char order,
DataType dataType) |
INDArray |
CpuNDArrayFactory.create(float[] data,
long[] shape,
long[] stride,
char order,
DataType dataType,
MemoryWorkspace workspace) |
INDArray |
CpuNDArrayFactory.create(float[] data,
long[] shape,
long[] stride,
char order,
long offset) |
INDArray |
CpuNDArrayFactory.create(float[] data,
long[] shape,
long[] stride,
DataType dataType,
MemoryWorkspace workspace) |
INDArray |
CpuNDArrayFactory.create(float[] data,
long[] shape,
long[] stride,
long offset) |
INDArray |
CpuNDArrayFactory.create(float[] data,
long[] shape,
long[] stride,
long offset,
char ordering) |
INDArray |
CpuNDArrayFactory.create(float[] data,
long[] shape,
long offset,
Character order) |
INDArray |
CpuNDArrayFactory.create(float[] data,
long rows,
long columns,
int[] stride,
long offset,
char ordering) |
INDArray |
CpuNDArrayFactory.create(int[] shape,
char ordering) |
INDArray |
CpuNDArrayFactory.create(int[] shape,
DataBuffer buffer) |
INDArray |
CpuNDArrayFactory.create(int[] data,
long[] shape,
long[] stride,
char order,
DataType dataType,
MemoryWorkspace workspace) |
INDArray |
CpuNDArrayFactory.create(int[] data,
long[] shape,
long[] stride,
DataType dataType,
MemoryWorkspace workspace) |
INDArray |
CpuNDArrayFactory.create(List<INDArray> list,
int[] shape)
Creates an ndarray with the specified shape
|
INDArray |
CpuNDArrayFactory.create(List<INDArray> list,
int[] shape,
char ordering) |
INDArray |
CpuNDArrayFactory.create(List<INDArray> list,
long[] shape) |
INDArray |
CpuNDArrayFactory.create(List<INDArray> list,
long[] shape,
char ordering) |
INDArray |
CpuNDArrayFactory.create(long[] shape,
char ordering) |
INDArray |
CpuNDArrayFactory.create(long[] data,
long[] shape,
long[] stride,
char order,
DataType dataType,
MemoryWorkspace workspace) |
INDArray |
CpuNDArrayFactory.create(long[] data,
long[] shape,
long[] stride,
DataType dataType,
MemoryWorkspace workspace) |
INDArray |
CpuNDArrayFactory.create(long rows,
long columns,
long[] stride,
long offset) |
INDArray |
CpuNDArrayFactory.create(short[] data,
long[] shape,
long[] stride,
char order,
DataType dataType,
MemoryWorkspace workspace) |
INDArray |
CpuNDArrayFactory.create(short[] data,
long[] shape,
long[] stride,
DataType dataType,
MemoryWorkspace workspace) |
INDArray |
CpuNDArrayFactory.createUninitialized(DataType dataType,
long[] shape,
char ordering,
MemoryWorkspace workspace) |
INDArray |
CpuNDArrayFactory.createUninitialized(int[] shape,
char ordering) |
INDArray |
CpuNDArrayFactory.createUninitialized(long[] shape,
char ordering) |
INDArray |
CpuNDArrayFactory.createUninitializedDetached(DataType dataType,
char ordering,
long... shape) |
INDArray |
CpuNDArrayFactory.empty(DataType type) |
INDArray |
CpuNDArrayFactory.pullRows(INDArray source,
INDArray destination,
int sourceDimension,
int[] indexes) |
INDArray |
CpuNDArrayFactory.pullRows(INDArray source,
INDArray destination,
int sourceDimension,
long[] indexes) |
INDArray |
CpuNDArrayFactory.pullRows(INDArray source,
int sourceDimension,
int[] indexes)
This method produces concatenated array, that consist from tensors, fetched from source array, against some dimension and specified indexes
|
INDArray |
CpuNDArrayFactory.pullRows(INDArray source,
int sourceDimension,
int[] indexes,
char order) |
INDArray |
CpuNDArrayFactory.pullRows(INDArray source,
int sourceDimension,
long[] indexes) |
INDArray |
CpuNDArrayFactory.pullRows(INDArray source,
int sourceDimension,
long[] indexes,
char order)
This method produces concatenated array, that consist from tensors, fetched from source array, against some dimension and specified indexes
|
INDArray |
CpuNDArrayFactory.sort(INDArray x,
boolean descending) |
INDArray |
CpuNDArrayFactory.sort(INDArray x,
boolean descending,
int... dimension) |
INDArray |
CpuNDArrayFactory.sortCooIndices(INDArray x) |
INDArray |
CpuNDArrayFactory.specialConcat(int dimension,
INDArray... toConcat)
For CPU backend this method is equal to concat()
|
INDArray[] |
CpuNDArrayFactory.tear(INDArray tensor,
int... dimensions) |
INDArray |
CpuNDArrayFactory.toFlattened(char order,
Collection<INDArray> matrices) |
INDArray |
NDArray.unsafeDuplication() |
INDArray |
NDArray.unsafeDuplication(boolean blocking) |
| Modifier and Type | Method and Description |
|---|---|
INDArray |
CpuNDArrayFactory.accumulate(INDArray target,
INDArray... arrays) |
INDArray |
CpuNDArrayFactory.accumulate(INDArray target,
INDArray... arrays) |
INDArray |
CpuNDArrayFactory.average(INDArray[] arrays) |
INDArray |
CpuNDArrayFactory.average(INDArray target,
Collection<INDArray> arrays)
This method averages input arrays, and returns averaged array
|
INDArray |
CpuNDArrayFactory.average(INDArray target,
INDArray[] arrays)
This method averages input arrays, and returns averaged array
|
INDArray |
CpuNDArrayFactory.average(INDArray target,
INDArray[] arrays)
This method averages input arrays, and returns averaged array
|
void |
CpuMemoryManager.collect(INDArray... arrays)
This method detaches off-heap memory from passed INDArray instances, and optionally stores them in cache for future reuse
PLEASE NOTE: Cache options depend on specific implementations
|
INDArray |
CpuNDArrayFactory.concat(int dimension,
INDArray... toConcat)
concatenate ndarrays along a dimension
|
INDArray |
CpuNDArrayFactory.convertDataEx(DataTypeEx typeSrc,
INDArray source,
DataTypeEx typeDst)
This method converts Single/Double precision databuffer to Half-precision databuffer
|
Pair<DataBuffer,DataBuffer> |
CpuTADManager.getTADOnlyShapeInfo(INDArray array,
int[] dimension) |
void |
CpuMemoryManager.memset(INDArray array) |
INDArray |
CpuNDArrayFactory.pullRows(INDArray source,
INDArray destination,
int sourceDimension,
int[] indexes) |
INDArray |
CpuNDArrayFactory.pullRows(INDArray source,
INDArray destination,
int sourceDimension,
long[] indexes) |
INDArray |
CpuNDArrayFactory.pullRows(INDArray source,
int sourceDimension,
int[] indexes)
This method produces concatenated array, that consist from tensors, fetched from source array, against some dimension and specified indexes
|
INDArray |
CpuNDArrayFactory.pullRows(INDArray source,
int sourceDimension,
int[] indexes,
char order) |
INDArray |
CpuNDArrayFactory.pullRows(INDArray source,
int sourceDimension,
long[] indexes) |
INDArray |
CpuNDArrayFactory.pullRows(INDArray source,
int sourceDimension,
long[] indexes,
char order)
This method produces concatenated array, that consist from tensors, fetched from source array, against some dimension and specified indexes
|
void |
CpuNDArrayFactory.shuffle(INDArray array,
Random rnd,
int... dimension)
In place shuffle of an ndarray
along a specified set of dimensions
|
INDArray |
CpuNDArrayFactory.sort(INDArray x,
boolean descending) |
INDArray |
CpuNDArrayFactory.sort(INDArray x,
boolean descending,
int... dimension) |
INDArray |
CpuNDArrayFactory.sortCooIndices(INDArray x) |
INDArray |
CpuNDArrayFactory.specialConcat(int dimension,
INDArray... toConcat)
For CPU backend this method is equal to concat()
|
INDArray[] |
CpuNDArrayFactory.tear(INDArray tensor,
int... dimensions) |
void |
CpuAffinityManager.touch(INDArray array)
Utility method, to associate INDArray with specific device (backend-specific)
Has no effect on CPU backend.
|
| Modifier and Type | Method and Description |
|---|---|
INDArray |
CpuNDArrayFactory.average(Collection<INDArray> arrays) |
INDArray |
CpuNDArrayFactory.average(INDArray target,
Collection<INDArray> arrays)
This method averages input arrays, and returns averaged array
|
INDArray |
CpuNDArrayFactory.create(List<INDArray> list,
int[] shape)
Creates an ndarray with the specified shape
|
INDArray |
CpuNDArrayFactory.create(List<INDArray> list,
int[] shape,
char ordering) |
INDArray |
CpuNDArrayFactory.create(List<INDArray> list,
long[] shape) |
INDArray |
CpuNDArrayFactory.create(List<INDArray> list,
long[] shape,
char ordering) |
void |
CpuNDArrayFactory.shuffle(Collection<INDArray> array,
Random rnd,
int... dimension)
Symmetric in place shuffle of an ndarray
along a specified set of dimensions.
|
void |
CpuNDArrayFactory.shuffle(List<INDArray> arrays,
Random rnd,
List<int[]> dimensions)
Symmetric in place shuffle of an ndarray
along a specified set of dimensions.
|
INDArray |
CpuNDArrayFactory.toFlattened(char order,
Collection<INDArray> matrices) |
| Constructor and Description |
|---|
NDArray(List<INDArray> slices,
int[] shape)
Create an ndarray from the specified slices.
|
NDArray(List<INDArray> slices,
int[] shape,
char ordering)
Create an ndarray from the specified slices.
|
NDArray(List<INDArray> slices,
int[] shape,
int[] stride)
Create an ndarray from the specified slices.
|
NDArray(List<INDArray> slices,
int[] shape,
int[] stride,
char ordering)
Create an ndarray from the specified slices.
|
NDArray(List<INDArray> slices,
long[] shape) |
NDArray(List<INDArray> slices,
long[] shape,
char ordering) |
NDArray(List<INDArray> slices,
long[] shape,
long[] stride) |
| Modifier and Type | Method and Description |
|---|---|
protected double |
CpuLevel1.dasum(long N,
INDArray X,
int incX) |
protected void |
CpuLevel1.daxpy(long N,
double alpha,
INDArray X,
int incX,
INDArray Y,
int incY) |
protected void |
CpuLevel1.dcopy(long N,
INDArray X,
int incX,
INDArray Y,
int incY) |
protected double |
CpuLevel1.ddot(long N,
INDArray X,
int incX,
INDArray Y,
int incY) |
protected void |
CpuLevel2.dgbmv(char order,
char TransA,
int M,
int N,
int KL,
int KU,
double alpha,
INDArray A,
int lda,
INDArray X,
int incX,
double beta,
INDArray Y,
int incY) |
protected void |
CpuLevel3.dgemm(char Order,
char TransA,
char TransB,
int M,
int N,
int K,
double alpha,
INDArray A,
int lda,
INDArray B,
int ldb,
double beta,
INDArray C,
int ldc) |
protected void |
CpuLevel2.dgemv(char order,
char TransA,
int M,
int N,
double alpha,
INDArray A,
int lda,
INDArray X,
int incX,
double beta,
INDArray Y,
int incY) |
void |
CpuLapack.dgeqrf(int M,
int N,
INDArray A,
INDArray R,
INDArray INFO) |
protected void |
CpuLevel2.dger(char order,
int M,
int N,
double alpha,
INDArray X,
int incX,
INDArray Y,
int incY,
INDArray A,
int lda) |
void |
CpuLapack.dgesvd(byte jobu,
byte jobvt,
int M,
int N,
INDArray A,
INDArray S,
INDArray U,
INDArray VT,
INDArray INFO) |
void |
CpuLapack.dgetrf(int M,
int N,
INDArray A,
INDArray IPIV,
INDArray INFO) |
protected double |
CpuLevel1.dnrm2(long N,
INDArray X,
int incX) |
void |
CpuLapack.dpotrf(byte uplo,
int N,
INDArray A,
INDArray INFO) |
protected void |
CpuLevel1.drot(long N,
INDArray X,
int incX,
INDArray Y,
int incY,
double c,
double s) |
protected void |
CpuLevel1.drotm(long N,
INDArray X,
int incX,
INDArray Y,
int incY,
INDArray P) |
protected void |
CpuLevel1.drotmg(double d1,
double d2,
double b1,
double b2,
INDArray P) |
protected void |
CpuLevel2.dsbmv(char order,
char Uplo,
int N,
int K,
double alpha,
INDArray A,
int lda,
INDArray X,
int incX,
double beta,
INDArray Y,
int incY) |
protected void |
CpuLevel1.dscal(long N,
double alpha,
INDArray X,
int incX) |
protected double |
CpuLevel1.dsdot(long N,
INDArray X,
int incX,
INDArray Y,
int incY) |
protected void |
CpuLevel2.dspmv(char order,
char Uplo,
int N,
double alpha,
INDArray Ap,
INDArray X,
int incX,
double beta,
INDArray Y,
int incY) |
protected void |
CpuLevel2.dspr(char order,
char Uplo,
int N,
double alpha,
INDArray X,
int incX,
INDArray Ap) |
protected void |
CpuLevel2.dspr2(char order,
char Uplo,
int N,
double alpha,
INDArray X,
int incX,
INDArray Y,
int incY,
INDArray A) |
protected void |
CpuLevel1.dswap(long N,
INDArray X,
int incX,
INDArray Y,
int incY) |
int |
CpuLapack.dsyev(char jobz,
char uplo,
int N,
INDArray A,
INDArray R) |
protected void |
CpuLevel3.dsymm(char Order,
char Side,
char Uplo,
int M,
int N,
double alpha,
INDArray A,
int lda,
INDArray B,
int ldb,
double beta,
INDArray C,
int ldc) |
protected void |
CpuLevel2.dsymv(char order,
char Uplo,
int N,
double alpha,
INDArray A,
int lda,
INDArray X,
int incX,
double beta,
INDArray Y,
int incY) |
protected void |
CpuLevel2.dsyr(char order,
char Uplo,
int N,
double alpha,
INDArray X,
int incX,
INDArray A,
int lda) |
protected void |
CpuLevel2.dsyr2(char order,
char Uplo,
int N,
double alpha,
INDArray X,
int incX,
INDArray Y,
int incY,
INDArray A,
int lda) |
protected void |
CpuLevel3.dsyr2k(char Order,
char Uplo,
char Trans,
int N,
int K,
double alpha,
INDArray A,
int lda,
INDArray B,
int ldb,
double beta,
INDArray C,
int ldc) |
protected void |
CpuLevel3.dsyrk(char Order,
char Uplo,
char Trans,
int N,
int K,
double alpha,
INDArray A,
int lda,
double beta,
INDArray C,
int ldc) |
protected void |
CpuLevel2.dtbmv(char order,
char Uplo,
char TransA,
char Diag,
int N,
int K,
INDArray A,
int lda,
INDArray X,
int incX) |
protected void |
CpuLevel2.dtbsv(char order,
char Uplo,
char TransA,
char Diag,
int N,
int K,
INDArray A,
int lda,
INDArray X,
int incX) |
protected void |
CpuLevel2.dtpmv(char order,
char Uplo,
char TransA,
char Diag,
int N,
INDArray Ap,
INDArray X,
int incX) |
protected void |
CpuLevel2.dtpsv(char order,
char Uplo,
char TransA,
char Diag,
int N,
INDArray Ap,
INDArray X,
int incX) |
protected void |
CpuLevel3.dtrmm(char Order,
char Side,
char Uplo,
char TransA,
char Diag,
int M,
int N,
double alpha,
INDArray A,
int lda,
INDArray B,
int ldb) |
protected void |
CpuLevel2.dtrmv(char order,
char Uplo,
char TransA,
char Diag,
int N,
INDArray A,
int lda,
INDArray X,
int incX) |
protected void |
CpuLevel3.dtrsm(char Order,
char Side,
char Uplo,
char TransA,
char Diag,
int M,
int N,
double alpha,
INDArray A,
int lda,
INDArray B,
int ldb) |
protected void |
CpuLevel2.dtrsv(char order,
char Uplo,
char TransA,
char Diag,
int N,
INDArray A,
int lda,
INDArray X,
int incX) |
protected static int |
CpuLapack.getColumnOrder(INDArray A) |
protected static int |
CpuLapack.getLda(INDArray A) |
void |
CpuLapack.getri(int N,
INDArray A,
int lda,
int[] IPIV,
INDArray WORK,
int lwork,
int INFO)
Generate inverse given LU decomp
|
protected float |
CpuLevel1.hasum(long N,
INDArray X,
int incX) |
protected void |
CpuLevel1.haxpy(long N,
float alpha,
INDArray X,
int incX,
INDArray Y,
int incY) |
protected float |
CpuLevel1.hdot(long N,
INDArray X,
int incX,
INDArray Y,
int incY) |
protected void |
CpuLevel3.hgemm(char Order,
char TransA,
char TransB,
int M,
int N,
int K,
float alpha,
INDArray A,
int lda,
INDArray B,
int ldb,
float beta,
INDArray C,
int ldc) |
protected int |
CpuLevel1.idamax(long N,
INDArray X,
int incX) |
protected int |
CpuLevel1.isamax(long N,
INDArray X,
int incX) |
protected float |
CpuLevel1.sasum(long N,
INDArray X,
int incX) |
protected void |
CpuLevel1.saxpy(long N,
float alpha,
INDArray X,
int incX,
INDArray Y,
int incY) |
protected void |
CpuLevel1.scopy(long N,
INDArray X,
int incX,
INDArray Y,
int incY) |
protected float |
CpuLevel1.sdot(long N,
INDArray X,
int incX,
INDArray Y,
int incY) |
protected float |
CpuLevel1.sdsdot(long N,
float alpha,
INDArray X,
int incX,
INDArray Y,
int incY) |
protected void |
CpuLevel2.sgbmv(char order,
char TransA,
int M,
int N,
int KL,
int KU,
float alpha,
INDArray A,
int lda,
INDArray X,
int incX,
float beta,
INDArray Y,
int incY) |
protected void |
CpuLevel3.sgemm(char Order,
char TransA,
char TransB,
int M,
int N,
int K,
float alpha,
INDArray A,
int lda,
INDArray B,
int ldb,
float beta,
INDArray C,
int ldc) |
protected void |
CpuLevel2.sgemv(char order,
char TransA,
int M,
int N,
float alpha,
INDArray A,
int lda,
INDArray X,
int incX,
float beta,
INDArray Y,
int incY) |
void |
CpuLapack.sgeqrf(int M,
int N,
INDArray A,
INDArray R,
INDArray INFO) |
protected void |
CpuLevel2.sger(char order,
int M,
int N,
float alpha,
INDArray X,
int incX,
INDArray Y,
int incY,
INDArray A,
int lda) |
void |
CpuLapack.sgesvd(byte jobu,
byte jobvt,
int M,
int N,
INDArray A,
INDArray S,
INDArray U,
INDArray VT,
INDArray INFO) |
void |
CpuLapack.sgetrf(int M,
int N,
INDArray A,
INDArray IPIV,
INDArray INFO) |
protected float |
CpuLevel1.snrm2(long N,
INDArray X,
int incX) |
void |
CpuLapack.spotrf(byte uplo,
int N,
INDArray A,
INDArray INFO) |
protected void |
CpuLevel1.srot(long N,
INDArray X,
int incX,
INDArray Y,
int incY,
float c,
float s) |
protected void |
CpuLevel1.srotm(long N,
INDArray X,
int incX,
INDArray Y,
int incY,
INDArray P) |
protected void |
CpuLevel1.srotmg(float d1,
float d2,
float b1,
float b2,
INDArray P) |
protected void |
CpuLevel2.ssbmv(char order,
char Uplo,
int N,
int K,
float alpha,
INDArray A,
int lda,
INDArray X,
int incX,
float beta,
INDArray Y,
int incY) |
protected void |
CpuLevel1.sscal(long N,
float alpha,
INDArray X,
int incX) |
protected void |
CpuLevel2.sspmv(char order,
char Uplo,
int N,
float alpha,
INDArray Ap,
INDArray X,
int incX,
float beta,
INDArray Y,
int incY) |
protected void |
CpuLevel2.sspr(char order,
char Uplo,
int N,
float alpha,
INDArray X,
int incX,
INDArray Ap) |
protected void |
CpuLevel2.sspr2(char order,
char Uplo,
int N,
float alpha,
INDArray X,
int incX,
INDArray Y,
int incY,
INDArray A) |
protected void |
CpuLevel1.sswap(long N,
INDArray X,
int incX,
INDArray Y,
int incY) |
int |
CpuLapack.ssyev(char jobz,
char uplo,
int N,
INDArray A,
INDArray R) |
protected void |
CpuLevel3.ssymm(char Order,
char Side,
char Uplo,
int M,
int N,
float alpha,
INDArray A,
int lda,
INDArray B,
int ldb,
float beta,
INDArray C,
int ldc) |
protected void |
CpuLevel2.ssymv(char order,
char Uplo,
int N,
float alpha,
INDArray A,
int lda,
INDArray X,
int incX,
float beta,
INDArray Y,
int incY) |
protected void |
CpuLevel2.ssyr(char order,
char Uplo,
int N,
float alpha,
INDArray X,
int incX,
INDArray A,
int lda) |
protected void |
CpuLevel2.ssyr2(char order,
char Uplo,
int N,
float alpha,
INDArray X,
int incX,
INDArray Y,
int incY,
INDArray A,
int lda) |
protected void |
CpuLevel3.ssyr2k(char Order,
char Uplo,
char Trans,
int N,
int K,
float alpha,
INDArray A,
int lda,
INDArray B,
int ldb,
float beta,
INDArray C,
int ldc) |
protected void |
CpuLevel3.ssyrk(char Order,
char Uplo,
char Trans,
int N,
int K,
float alpha,
INDArray A,
int lda,
float beta,
INDArray C,
int ldc) |
protected void |
CpuLevel2.stbmv(char order,
char Uplo,
char TransA,
char Diag,
int N,
int K,
INDArray A,
int lda,
INDArray X,
int incX) |
protected void |
CpuLevel2.stbsv(char order,
char Uplo,
char TransA,
char Diag,
int N,
int K,
INDArray A,
int lda,
INDArray X,
int incX) |
protected void |
CpuLevel2.stpmv(char order,
char Uplo,
char TransA,
char Diag,
int N,
INDArray Ap,
INDArray X,
int incX) |
protected void |
CpuLevel2.stpsv(char order,
char Uplo,
char TransA,
char Diag,
int N,
INDArray Ap,
INDArray X,
int incX) |
protected void |
CpuLevel3.strmm(char Order,
char Side,
char Uplo,
char TransA,
char Diag,
int M,
int N,
float alpha,
INDArray A,
int lda,
INDArray B,
int ldb) |
protected void |
CpuLevel2.strmv(char order,
char Uplo,
char TransA,
char Diag,
int N,
INDArray A,
int lda,
INDArray X,
int incX) |
protected void |
CpuLevel3.strsm(char Order,
char Side,
char Uplo,
char TransA,
char Diag,
int M,
int N,
float alpha,
INDArray A,
int lda,
INDArray B,
int ldb) |
protected void |
CpuLevel2.strsv(char order,
char Uplo,
char TransA,
char Diag,
int N,
INDArray A,
int lda,
INDArray X,
int incX) |
| Modifier and Type | Method and Description |
|---|---|
INDArray |
CpuThreshold.compress(INDArray array) |
| Modifier and Type | Method and Description |
|---|---|
INDArray |
CpuThreshold.compress(INDArray array) |
| Modifier and Type | Method and Description |
|---|---|
INDArray |
NativeOpExecutioner.bitmapDecode(INDArray encoded,
INDArray target) |
INDArray |
NativeOpExecutioner.exec(BroadcastOp op) |
INDArray[] |
NativeOpExecutioner.exec(CustomOp op)
This method executes given CustomOp
PLEASE NOTE: You're responsible for input/output validation
|
INDArray[] |
NativeOpExecutioner.exec(CustomOp op,
OpContext context) |
INDArray |
NativeOpExecutioner.exec(IndexAccumulation op) |
INDArray |
NativeOpExecutioner.exec(Op op) |
INDArray |
NativeOpExecutioner.exec(RandomOp op)
This method executes specified RandomOp using default RNG available via Nd4j.getRandom()
|
INDArray |
NativeOpExecutioner.exec(RandomOp op,
Random rng)
This method executes specific
RandomOp against specified RNG
|
INDArray |
NativeOpExecutioner.exec(ReduceOp op) |
INDArray |
NativeOpExecutioner.exec(ScalarOp op) |
INDArray |
NativeOpExecutioner.exec(Variance op) |
INDArray |
NativeOpExecutioner.thresholdDecode(INDArray encoded,
INDArray target) |
INDArray |
NativeOpExecutioner.thresholdEncode(INDArray input,
double threshold) |
INDArray |
NativeOpExecutioner.thresholdEncode(INDArray input,
double threshold,
Integer boundary) |
| Modifier and Type | Method and Description |
|---|---|
Map<String,INDArray> |
NativeOpExecutioner.executeGraph(long id,
Map<String,INDArray> map,
Map<String,Integer> reverseMap) |
| Modifier and Type | Method and Description |
|---|---|
INDArray |
NativeOpExecutioner.bitmapDecode(INDArray encoded,
INDArray target) |
long |
NativeOpExecutioner.bitmapEncode(INDArray indArray,
INDArray target,
double threshold) |
INDArrayStatistics |
NativeOpExecutioner.inspectArray(INDArray array) |
void |
NativeOpExecutioner.scatterUpdate(ScatterUpdate.UpdateOp op,
INDArray array,
INDArray indices,
INDArray updates,
int[] axis) |
void |
CpuOpContext.setInputArray(int index,
INDArray array) |
void |
CpuOpContext.setOutputArray(int index,
INDArray array) |
TadPack |
NativeOpExecutioner.tadShapeInfoAndOffsets(INDArray array,
int[] dimension) |
INDArray |
NativeOpExecutioner.thresholdDecode(INDArray encoded,
INDArray target) |
INDArray |
NativeOpExecutioner.thresholdEncode(INDArray input,
double threshold) |
INDArray |
NativeOpExecutioner.thresholdEncode(INDArray input,
double threshold,
Integer boundary) |
| Modifier and Type | Method and Description |
|---|---|
Map<String,INDArray> |
NativeOpExecutioner.executeGraph(long id,
Map<String,INDArray> map,
Map<String,Integer> reverseMap) |
| Modifier and Type | Method and Description |
|---|---|
INDArray |
DataSet.exampleMaxs() |
INDArray |
DataSet.exampleMeans() |
INDArray |
DataSet.exampleSums() |
INDArray[] |
MultiDataSet.getFeatures() |
INDArray |
DataSet.getFeatures() |
INDArray |
MultiDataSet.getFeatures(int index) |
INDArray |
DataSet.getFeaturesMaskArray() |
INDArray |
MultiDataSet.getFeaturesMaskArray(int index) |
INDArray[] |
MultiDataSet.getFeaturesMaskArrays() |
INDArray[] |
MultiDataSet.getLabels() |
INDArray |
DataSet.getLabels()
Returns the labels for the dataset
|
INDArray |
MultiDataSet.getLabels(int index) |
INDArray |
DataSet.getLabelsMaskArray() |
INDArray |
MultiDataSet.getLabelsMaskArray(int index) |
INDArray[] |
MultiDataSet.getLabelsMaskArrays() |
| Modifier and Type | Method and Description |
|---|---|
void |
DataSet.addFeatureVector(INDArray toAdd)
Adds a feature for each example on to the current feature vector
|
void |
DataSet.addFeatureVector(INDArray feature,
int example)
The feature to add, and the example/row number
|
List<String> |
DataSet.getLabelNames(INDArray idxs) |
void |
DataSet.setFeatures(INDArray features) |
void |
MultiDataSet.setFeatures(INDArray[] features) |
void |
MultiDataSet.setFeatures(int idx,
INDArray features) |
void |
DataSet.setFeaturesMaskArray(INDArray featuresMask) |
void |
MultiDataSet.setFeaturesMaskArray(int idx,
INDArray maskArray) |
void |
MultiDataSet.setFeaturesMaskArrays(INDArray[] maskArrays) |
void |
DataSet.setLabels(INDArray labels) |
void |
MultiDataSet.setLabels(INDArray[] labels) |
void |
MultiDataSet.setLabels(int idx,
INDArray labels) |
void |
DataSet.setLabelsMaskArray(INDArray labelsMask) |
void |
MultiDataSet.setLabelsMaskArray(INDArray[] labelsMaskArrays) |
void |
MultiDataSet.setLabelsMaskArray(int idx,
INDArray labelsMaskArray) |
| Constructor and Description |
|---|
DataSet(INDArray first,
INDArray second)
Creates a dataset with the specified input matrix and labels
|
DataSet(INDArray features,
INDArray labels,
INDArray featuresMask,
INDArray labelsMask)
Create a dataset with the specified input INDArray and labels (output) INDArray, plus (optionally) mask arrays
for the features and labels
|
MultiDataSet(INDArray[] features,
INDArray[] labels)
MultiDataSet constructor with no mask arrays
|
MultiDataSet(INDArray[] features,
INDArray[] labels)
MultiDataSet constructor with no mask arrays
|
MultiDataSet(INDArray[] features,
INDArray[] labels,
INDArray[] featuresMaskArrays,
INDArray[] labelsMaskArrays) |
MultiDataSet(INDArray[] features,
INDArray[] labels,
INDArray[] featuresMaskArrays,
INDArray[] labelsMaskArrays) |
MultiDataSet(INDArray[] features,
INDArray[] labels,
INDArray[] featuresMaskArrays,
INDArray[] labelsMaskArrays) |
MultiDataSet(INDArray[] features,
INDArray[] labels,
INDArray[] featuresMaskArrays,
INDArray[] labelsMaskArrays) |
MultiDataSet(INDArray features,
INDArray labels)
MultiDataSet constructor with single features/labels input, no mask arrays
|
MultiDataSet(INDArray features,
INDArray labels,
INDArray featuresMask,
INDArray labelsMask)
MultiDataSet constructor with single features/labels input, single mask arrays
|
| Modifier and Type | Method and Description |
|---|---|
INDArray |
DataSet.exampleMaxs() |
INDArray |
DataSet.exampleMeans() |
INDArray |
DataSet.exampleSums() |
INDArray[] |
MultiDataSet.getFeatures()
Get all of the input features, as an array of INDArrays
|
INDArray |
DataSet.getFeatures()
Returns the features array for the DataSet
|
INDArray |
MultiDataSet.getFeatures(int index)
Get a single feature/input array
|
INDArray |
DataSet.getFeaturesMaskArray()
Input mask array: a mask array for input, where each value is in {0,1} in order to specify whether an input is
actually present or not.
|
INDArray |
MultiDataSet.getFeaturesMaskArray(int index)
Get the specified feature mask array.
|
INDArray[] |
MultiDataSet.getFeaturesMaskArrays()
Get the feature mask arrays.
|
INDArray[] |
MultiDataSet.getLabels()
Get all of the labels, as an array of INDArrays
|
INDArray |
DataSet.getLabels() |
INDArray |
MultiDataSet.getLabels(int index)
Get a single label/output array
|
INDArray |
DataSet.getLabelsMaskArray()
Labels (output) mask array: a mask array for input, where each value is in {0,1} in order to specify whether an
output is actually present or not.
|
INDArray |
MultiDataSet.getLabelsMaskArray(int index)
Get the specified label mask array.
|
INDArray[] |
MultiDataSet.getLabelsMaskArrays()
Get the labels mask arrays.
|
static INDArray |
DataSetUtil.mergeMasks2d(long[] outShape,
INDArray[] arrays,
INDArray[] masks) |
static INDArray |
DataSetUtil.mergeMasks4d(INDArray[] featuresOrLabels,
INDArray[] masks) |
static INDArray |
DataSetUtil.mergePerOutputMasks2d(long[] outShape,
INDArray[][] arrays,
INDArray[][] masks,
int inOutIdx) |
static INDArray |
DataSetUtil.mergePerOutputMasks2d(long[] outShape,
INDArray[] arrays,
INDArray[] masks)
Deprecated.
|
static INDArray |
DataSetUtil.tailor2d(DataSet dataSet,
boolean areFeatures) |
static INDArray |
DataSetUtil.tailor2d(INDArray data,
INDArray mask) |
static INDArray |
DataSetUtil.tailor3d2d(DataSet dataset,
boolean areFeatures)
Deprecated.
|
static INDArray |
DataSetUtil.tailor3d2d(INDArray data,
INDArray mask) |
static INDArray |
DataSetUtil.tailor4d2d(DataSet dataset,
boolean areFeatures) |
static INDArray |
DataSetUtil.tailor4d2d(INDArray data) |
| Modifier and Type | Method and Description |
|---|---|
static Pair<INDArray,INDArray> |
DataSetUtil.merge2d(INDArray[][] arrays,
INDArray[][] masks,
int inOutIdx)
Merge the specified 2d arrays and masks.
|
static Pair<INDArray,INDArray> |
DataSetUtil.merge2d(INDArray[][] arrays,
INDArray[][] masks,
int inOutIdx)
Merge the specified 2d arrays and masks.
|
static Pair<INDArray,INDArray> |
DataSetUtil.merge2d(INDArray[] arrays,
INDArray[] masks)
Merge the specified 2d arrays and masks.
|
static Pair<INDArray,INDArray> |
DataSetUtil.merge2d(INDArray[] arrays,
INDArray[] masks)
Merge the specified 2d arrays and masks.
|
static Pair<INDArray,INDArray> |
DataSetUtil.merge4d(INDArray[][] arrays,
INDArray[][] masks,
int inOutIdx)
Merge the specified 4d arrays and masks.
|
static Pair<INDArray,INDArray> |
DataSetUtil.merge4d(INDArray[][] arrays,
INDArray[][] masks,
int inOutIdx)
Merge the specified 4d arrays and masks.
|
static Pair<INDArray,INDArray> |
DataSetUtil.merge4d(INDArray[] arrays,
INDArray[] masks)
Merge the specified 4d arrays and masks.
|
static Pair<INDArray,INDArray> |
DataSetUtil.merge4d(INDArray[] arrays,
INDArray[] masks)
Merge the specified 4d arrays and masks.
|
static Pair<INDArray,INDArray> |
DataSetUtil.mergeFeatures(INDArray[][] featuresToMerge,
INDArray[][] featureMasksToMerge,
int inOutIdx)
Extract out the specified column, and merge the specified features and mask arrays (i.e., concatenate the examples)
|
static Pair<INDArray,INDArray> |
DataSetUtil.mergeFeatures(INDArray[][] featuresToMerge,
INDArray[][] featureMasksToMerge,
int inOutIdx)
Extract out the specified column, and merge the specified features and mask arrays (i.e., concatenate the examples)
|
static Pair<INDArray,INDArray> |
DataSetUtil.mergeFeatures(INDArray[] featuresToMerge,
INDArray[] featureMasksToMerge)
Merge the specified features and mask arrays (i.e., concatenate the examples)
|
static Pair<INDArray,INDArray> |
DataSetUtil.mergeFeatures(INDArray[] featuresToMerge,
INDArray[] featureMasksToMerge)
Merge the specified features and mask arrays (i.e., concatenate the examples)
|
static Pair<INDArray,INDArray> |
DataSetUtil.mergeLabels(INDArray[][] labelsToMerge,
INDArray[][] labelMasksToMerge,
int inOutIdx)
Extract out the specified column, and merge the specified label and label mask arrays
(i.e., concatenate the examples)
|
static Pair<INDArray,INDArray> |
DataSetUtil.mergeLabels(INDArray[][] labelsToMerge,
INDArray[][] labelMasksToMerge,
int inOutIdx)
Extract out the specified column, and merge the specified label and label mask arrays
(i.e., concatenate the examples)
|
static Pair<INDArray,INDArray> |
DataSetUtil.mergeLabels(INDArray[] labelsToMerge,
INDArray[] labelMasksToMerge)
Merge the specified labels and label mask arrays (i.e., concatenate the examples)
|
static Pair<INDArray,INDArray> |
DataSetUtil.mergeLabels(INDArray[] labelsToMerge,
INDArray[] labelMasksToMerge)
Merge the specified labels and label mask arrays (i.e., concatenate the examples)
|
static Pair<INDArray,INDArray> |
DataSetUtil.mergeTimeSeries(INDArray[][] arrays,
INDArray[][] masks,
int inOutIdx)
Merge the specified time series (3d) arrays and masks.
|
static Pair<INDArray,INDArray> |
DataSetUtil.mergeTimeSeries(INDArray[][] arrays,
INDArray[][] masks,
int inOutIdx)
Merge the specified time series (3d) arrays and masks.
|
static Pair<INDArray,INDArray> |
DataSetUtil.mergeTimeSeries(INDArray[] arrays,
INDArray[] masks)
Merge the specified time series (3d) arrays and masks.
|
static Pair<INDArray,INDArray> |
DataSetUtil.mergeTimeSeries(INDArray[] arrays,
INDArray[] masks)
Merge the specified time series (3d) arrays and masks.
|
| Modifier and Type | Method and Description |
|---|---|
void |
DataSet.addFeatureVector(INDArray toAdd) |
void |
DataSet.addFeatureVector(INDArray feature,
int example) |
List<String> |
DataSet.getLabelNames(INDArray idxs) |
static Pair<INDArray,INDArray> |
DataSetUtil.merge2d(INDArray[][] arrays,
INDArray[][] masks,
int inOutIdx)
Merge the specified 2d arrays and masks.
|
static Pair<INDArray,INDArray> |
DataSetUtil.merge2d(INDArray[][] arrays,
INDArray[][] masks,
int inOutIdx)
Merge the specified 2d arrays and masks.
|
static Pair<INDArray,INDArray> |
DataSetUtil.merge2d(INDArray[] arrays,
INDArray[] masks)
Merge the specified 2d arrays and masks.
|
static Pair<INDArray,INDArray> |
DataSetUtil.merge2d(INDArray[] arrays,
INDArray[] masks)
Merge the specified 2d arrays and masks.
|
static Pair<INDArray,INDArray> |
DataSetUtil.merge4d(INDArray[][] arrays,
INDArray[][] masks,
int inOutIdx)
Merge the specified 4d arrays and masks.
|
static Pair<INDArray,INDArray> |
DataSetUtil.merge4d(INDArray[][] arrays,
INDArray[][] masks,
int inOutIdx)
Merge the specified 4d arrays and masks.
|
static Pair<INDArray,INDArray> |
DataSetUtil.merge4d(INDArray[] arrays,
INDArray[] masks)
Merge the specified 4d arrays and masks.
|
static Pair<INDArray,INDArray> |
DataSetUtil.merge4d(INDArray[] arrays,
INDArray[] masks)
Merge the specified 4d arrays and masks.
|
static Pair<INDArray[],INDArray[]> |
DataSetUtil.mergeFeatures(INDArray[][] featuresToMerge,
INDArray[][] featureMasksToMerge)
Merge all of the features arrays into one minibatch.
|
static Pair<INDArray[],INDArray[]> |
DataSetUtil.mergeFeatures(INDArray[][] featuresToMerge,
INDArray[][] featureMasksToMerge)
Merge all of the features arrays into one minibatch.
|
static Pair<INDArray,INDArray> |
DataSetUtil.mergeFeatures(INDArray[][] featuresToMerge,
INDArray[][] featureMasksToMerge,
int inOutIdx)
Extract out the specified column, and merge the specified features and mask arrays (i.e., concatenate the examples)
|
static Pair<INDArray,INDArray> |
DataSetUtil.mergeFeatures(INDArray[][] featuresToMerge,
INDArray[][] featureMasksToMerge,
int inOutIdx)
Extract out the specified column, and merge the specified features and mask arrays (i.e., concatenate the examples)
|
static Pair<INDArray,INDArray> |
DataSetUtil.mergeFeatures(INDArray[] featuresToMerge,
INDArray[] featureMasksToMerge)
Merge the specified features and mask arrays (i.e., concatenate the examples)
|
static Pair<INDArray,INDArray> |
DataSetUtil.mergeFeatures(INDArray[] featuresToMerge,
INDArray[] featureMasksToMerge)
Merge the specified features and mask arrays (i.e., concatenate the examples)
|
static Pair<INDArray,INDArray> |
DataSetUtil.mergeLabels(INDArray[][] labelsToMerge,
INDArray[][] labelMasksToMerge,
int inOutIdx)
Extract out the specified column, and merge the specified label and label mask arrays
(i.e., concatenate the examples)
|
static Pair<INDArray,INDArray> |
DataSetUtil.mergeLabels(INDArray[][] labelsToMerge,
INDArray[][] labelMasksToMerge,
int inOutIdx)
Extract out the specified column, and merge the specified label and label mask arrays
(i.e., concatenate the examples)
|
static Pair<INDArray,INDArray> |
DataSetUtil.mergeLabels(INDArray[] labelsToMerge,
INDArray[] labelMasksToMerge)
Merge the specified labels and label mask arrays (i.e., concatenate the examples)
|
static Pair<INDArray,INDArray> |
DataSetUtil.mergeLabels(INDArray[] labelsToMerge,
INDArray[] labelMasksToMerge)
Merge the specified labels and label mask arrays (i.e., concatenate the examples)
|
static INDArray |
DataSetUtil.mergeMasks2d(long[] outShape,
INDArray[] arrays,
INDArray[] masks) |
static INDArray |
DataSetUtil.mergeMasks2d(long[] outShape,
INDArray[] arrays,
INDArray[] masks) |
static INDArray |
DataSetUtil.mergeMasks4d(INDArray[] featuresOrLabels,
INDArray[] masks) |
static INDArray |
DataSetUtil.mergeMasks4d(INDArray[] featuresOrLabels,
INDArray[] masks) |
static INDArray |
DataSetUtil.mergePerOutputMasks2d(long[] outShape,
INDArray[][] arrays,
INDArray[][] masks,
int inOutIdx) |
static INDArray |
DataSetUtil.mergePerOutputMasks2d(long[] outShape,
INDArray[][] arrays,
INDArray[][] masks,
int inOutIdx) |
static INDArray |
DataSetUtil.mergePerOutputMasks2d(long[] outShape,
INDArray[] arrays,
INDArray[] masks)
Deprecated.
|
static INDArray |
DataSetUtil.mergePerOutputMasks2d(long[] outShape,
INDArray[] arrays,
INDArray[] masks)
Deprecated.
|
static Pair<INDArray,INDArray> |
DataSetUtil.mergeTimeSeries(INDArray[][] arrays,
INDArray[][] masks,
int inOutIdx)
Merge the specified time series (3d) arrays and masks.
|
static Pair<INDArray,INDArray> |
DataSetUtil.mergeTimeSeries(INDArray[][] arrays,
INDArray[][] masks,
int inOutIdx)
Merge the specified time series (3d) arrays and masks.
|
static Pair<INDArray,INDArray> |
DataSetUtil.mergeTimeSeries(INDArray[] arrays,
INDArray[] masks)
Merge the specified time series (3d) arrays and masks.
|
static Pair<INDArray,INDArray> |
DataSetUtil.mergeTimeSeries(INDArray[] arrays,
INDArray[] masks)
Merge the specified time series (3d) arrays and masks.
|
void |
DataSet.setFeatures(INDArray features)
Set the features array for the DataSet
|
void |
MultiDataSet.setFeatures(INDArray[] features)
Set all of the features arrays for the MultiDataSet
|
void |
MultiDataSet.setFeatures(int idx,
INDArray features)
Set a single features array (by index) for the MultiDataSet
|
void |
DataSet.setFeaturesMaskArray(INDArray inputMask)
Set the features mask array in this DataSet
|
void |
MultiDataSet.setFeaturesMaskArray(int idx,
INDArray maskArray)
Set a single feature mask array by index
|
void |
MultiDataSet.setFeaturesMaskArrays(INDArray[] maskArrays)
Set the feature mask arrays
|
void |
DataSet.setLabels(INDArray labels) |
void |
MultiDataSet.setLabels(INDArray[] labels)
Set all of the labels arrays for the MultiDataSet
|
void |
MultiDataSet.setLabels(int idx,
INDArray labels)
Set a single labels array (by index) for the MultiDataSet
|
void |
DataSet.setLabelsMaskArray(INDArray labelsMask)
Set the labels mask array in this data set
|
void |
MultiDataSet.setLabelsMaskArray(INDArray[] labels)
Set the labels mask arrays
|
void |
MultiDataSet.setLabelsMaskArray(int idx,
INDArray labelsMaskArray)
Set a single labels mask array by index
|
static void |
DataSetUtil.setMaskedValuesToZero(INDArray data,
INDArray mask) |
static INDArray |
DataSetUtil.tailor2d(INDArray data,
INDArray mask) |
static INDArray |
DataSetUtil.tailor3d2d(INDArray data,
INDArray mask) |
static INDArray |
DataSetUtil.tailor4d2d(INDArray data) |
| Modifier and Type | Method and Description |
|---|---|
INDArray |
StandardScaler.getMean()
Deprecated.
|
INDArray |
StandardScaler.getStd()
Deprecated.
|
| Modifier and Type | Method and Description |
|---|---|
protected INDArray |
BaseDataFetcher.createInputMatrix(int numRows)
Creates a feature vector
|
protected INDArray |
BaseDataFetcher.createOutputMatrix(int numRows) |
protected INDArray |
BaseDataFetcher.createOutputVector(int outcomeLabel)
Creates an output label matrix
|
| Modifier and Type | Field and Description |
|---|---|
static INDArray |
VGG16ImagePreProcessor.VGG_MEAN_OFFSET_BGR |
static INDArray |
VGG16ImagePreProcessor.VGG_MEAN_OFFSET_BGR_FLOAT |
static INDArray |
VGG16ImagePreProcessor.VGG_MEAN_OFFSET_BGR_FLOAT16 |
| Modifier and Type | Method and Description |
|---|---|
INDArray |
MultiNormalizerStandardize.getFeatureMean(int input) |
INDArray |
MultiNormalizerStandardize.getFeatureStd(int input) |
INDArray |
NormalizerMinMaxScaler.getLabelMax() |
INDArray |
MultiNormalizerMinMaxScaler.getLabelMax(int output) |
INDArray |
NormalizerStandardize.getLabelMean() |
INDArray |
MultiNormalizerStandardize.getLabelMean(int output) |
INDArray |
NormalizerMinMaxScaler.getLabelMin() |
INDArray |
MultiNormalizerMinMaxScaler.getLabelMin(int output) |
INDArray |
NormalizerStandardize.getLabelStd() |
INDArray |
MultiNormalizerStandardize.getLabelStd(int output) |
INDArray |
NormalizerMinMaxScaler.getMax() |
INDArray |
MultiNormalizerMinMaxScaler.getMax(int input) |
INDArray |
NormalizerStandardize.getMean() |
protected static INDArray |
VGG16ImagePreProcessor.getMeanFor(INDArray features) |
INDArray |
NormalizerMinMaxScaler.getMin() |
INDArray |
MultiNormalizerMinMaxScaler.getMin(int input) |
INDArray |
NormalizerStandardize.getStd() |
| Modifier and Type | Method and Description |
|---|---|
protected static INDArray |
VGG16ImagePreProcessor.getMeanFor(INDArray features) |
void |
VGG16ImagePreProcessor.preProcess(INDArray features) |
void |
ImagePreProcessingScaler.preProcess(INDArray features) |
void |
StandardizeStrategy.preProcess(INDArray array,
INDArray maskArray,
DistributionStats stats)
Normalize a data array
|
void |
MinMaxStrategy.preProcess(INDArray array,
INDArray maskArray,
MinMaxStats stats)
Normalize a data array
|
void |
NormalizerStrategy.preProcess(INDArray array,
INDArray maskArray,
S stats)
Normalize a data array
|
void |
StandardizeStrategy.revert(INDArray array,
INDArray maskArray,
DistributionStats stats)
Denormalize a data array
|
void |
MinMaxStrategy.revert(INDArray array,
INDArray maskArray,
MinMaxStats stats)
Denormalize a data array
|
void |
NormalizerStrategy.revert(INDArray array,
INDArray maskArray,
S stats)
Denormalize a data array
|
void |
VGG16ImagePreProcessor.revertFeatures(INDArray features) |
void |
ImagePreProcessingScaler.revertFeatures(INDArray features) |
void |
DataNormalization.revertFeatures(INDArray features)
Undo (revert) the normalization applied by this DataNormalization instance to the specified features array
|
void |
AbstractDataSetNormalizer.revertFeatures(INDArray features) |
void |
MultiNormalizerHybrid.revertFeatures(INDArray[] features)
Undo (revert) the normalization applied by this DataNormalization instance to the entire inputs array
|
void |
MultiDataNormalization.revertFeatures(INDArray[] features)
Undo (revert) the normalization applied by this DataNormalization instance to the specified features array
|
void |
ImageMultiPreProcessingScaler.revertFeatures(INDArray[] features) |
void |
AbstractMultiDataSetNormalizer.revertFeatures(INDArray[] features)
Undo (revert) the normalization applied by this normalizer to the features arrays
|
void |
MultiNormalizerHybrid.revertFeatures(INDArray[] features,
INDArray[] maskArrays)
Undo (revert) the normalization applied by this DataNormalization instance to the entire inputs array
|
void |
MultiNormalizerHybrid.revertFeatures(INDArray[] features,
INDArray[] maskArrays)
Undo (revert) the normalization applied by this DataNormalization instance to the entire inputs array
|
void |
MultiDataNormalization.revertFeatures(INDArray[] features,
INDArray[] featuresMask)
Undo (revert) the normalization applied by this DataNormalization instance to the specified features array
|
void |
MultiDataNormalization.revertFeatures(INDArray[] features,
INDArray[] featuresMask)
Undo (revert) the normalization applied by this DataNormalization instance to the specified features array
|
void |
ImageMultiPreProcessingScaler.revertFeatures(INDArray[] features,
INDArray[] featuresMask) |
void |
ImageMultiPreProcessingScaler.revertFeatures(INDArray[] features,
INDArray[] featuresMask) |
void |
AbstractMultiDataSetNormalizer.revertFeatures(INDArray[] features,
INDArray[] maskArrays)
Undo (revert) the normalization applied by this normalizer to the features arrays
|
void |
AbstractMultiDataSetNormalizer.revertFeatures(INDArray[] features,
INDArray[] maskArrays)
Undo (revert) the normalization applied by this normalizer to the features arrays
|
void |
MultiNormalizerHybrid.revertFeatures(INDArray[] features,
INDArray[] maskArrays,
int input)
Undo (revert) the normalization applied by this DataNormalization instance to the features of a particular input
|
void |
MultiNormalizerHybrid.revertFeatures(INDArray[] features,
INDArray[] maskArrays,
int input)
Undo (revert) the normalization applied by this DataNormalization instance to the features of a particular input
|
void |
VGG16ImagePreProcessor.revertFeatures(INDArray features,
INDArray featuresMask) |
void |
ImagePreProcessingScaler.revertFeatures(INDArray features,
INDArray featuresMask) |
void |
DataNormalization.revertFeatures(INDArray features,
INDArray featuresMask)
Undo (revert) the normalization applied by this DataNormalization instance to the specified features array
|
void |
AbstractDataSetNormalizer.revertFeatures(INDArray features,
INDArray featuresMask) |
void |
AbstractMultiDataSetNormalizer.revertFeatures(INDArray features,
INDArray mask,
int input)
Undo (revert) the normalization applied by this normalizer to a specific features array.
|
void |
VGG16ImagePreProcessor.revertLabels(INDArray labels) |
void |
ImagePreProcessingScaler.revertLabels(INDArray labels) |
void |
DataNormalization.revertLabels(INDArray labels)
Undo (revert) the normalization applied by this DataNormalization instance to the specified labels array.
|
void |
AbstractDataSetNormalizer.revertLabels(INDArray labels)
Undo (revert) the normalization applied by this DataNormalization instance to the specified labels array.
|
void |
MultiNormalizerHybrid.revertLabels(INDArray[] labels)
Undo (revert) the normalization applied by this DataNormalization instance to the entire outputs array
|
void |
MultiDataNormalization.revertLabels(INDArray[] labels)
Undo (revert) the normalization applied by this DataNormalization instance to the specified labels array.
|
void |
ImageMultiPreProcessingScaler.revertLabels(INDArray[] labels) |
void |
AbstractMultiDataSetNormalizer.revertLabels(INDArray[] labels)
Undo (revert) the normalization applied by this DataNormalization instance to the specified labels array.
|
void |
MultiNormalizerHybrid.revertLabels(INDArray[] labels,
INDArray[] maskArrays)
Undo (revert) the normalization applied by this DataNormalization instance to the entire outputs array
|
void |
MultiNormalizerHybrid.revertLabels(INDArray[] labels,
INDArray[] maskArrays)
Undo (revert) the normalization applied by this DataNormalization instance to the entire outputs array
|
void |
MultiDataNormalization.revertLabels(INDArray[] labels,
INDArray[] labelsMask)
Undo (revert) the normalization applied by this DataNormalization instance to the specified labels array.
|
void |
MultiDataNormalization.revertLabels(INDArray[] labels,
INDArray[] labelsMask)
Undo (revert) the normalization applied by this DataNormalization instance to the specified labels array.
|
void |
ImageMultiPreProcessingScaler.revertLabels(INDArray[] labels,
INDArray[] labelsMask) |
void |
ImageMultiPreProcessingScaler.revertLabels(INDArray[] labels,
INDArray[] labelsMask) |
void |
AbstractMultiDataSetNormalizer.revertLabels(INDArray[] labels,
INDArray[] labelsMask)
Undo (revert) the normalization applied by this normalizer to the labels arrays.
|
void |
AbstractMultiDataSetNormalizer.revertLabels(INDArray[] labels,
INDArray[] labelsMask)
Undo (revert) the normalization applied by this normalizer to the labels arrays.
|
void |
MultiNormalizerHybrid.revertLabels(INDArray[] labels,
INDArray[] maskArrays,
int output)
Undo (revert) the normalization applied by this DataNormalization instance to the labels of a particular output
|
void |
MultiNormalizerHybrid.revertLabels(INDArray[] labels,
INDArray[] maskArrays,
int output)
Undo (revert) the normalization applied by this DataNormalization instance to the labels of a particular output
|
void |
VGG16ImagePreProcessor.revertLabels(INDArray labels,
INDArray labelsMask) |
void |
ImagePreProcessingScaler.revertLabels(INDArray labels,
INDArray labelsMask) |
void |
DataNormalization.revertLabels(INDArray labels,
INDArray labelsMask)
Undo (revert) the normalization applied by this DataNormalization instance to the specified labels array.
|
void |
AbstractDataSetNormalizer.revertLabels(INDArray labels,
INDArray labelsMask) |
void |
AbstractMultiDataSetNormalizer.revertLabels(INDArray labels,
INDArray mask,
int output)
Undo (revert) the normalization applied by this normalizer to a specific labels array.
|
void |
NormalizerMinMaxScaler.setFeatureStats(INDArray featureMin,
INDArray featureMax) |
void |
NormalizerStandardize.setLabelStats(INDArray labelMean,
INDArray labelStd) |
void |
NormalizerMinMaxScaler.setLabelStats(INDArray labelMin,
INDArray labelMax) |
void |
VGG16ImagePreProcessor.transform(INDArray features) |
void |
ImagePreProcessingScaler.transform(INDArray features) |
void |
DataNormalization.transform(INDArray features)
Transform the dataset
|
void |
AbstractDataSetNormalizer.transform(INDArray features)
Transform the given INDArray
|
void |
VGG16ImagePreProcessor.transform(INDArray features,
INDArray featuresMask) |
void |
ImagePreProcessingScaler.transform(INDArray features,
INDArray featuresMask) |
void |
DataNormalization.transform(INDArray features,
INDArray featuresMask)
Transform the features, with an optional mask array
|
void |
AbstractDataSetNormalizer.transform(INDArray features,
INDArray featuresMask) |
void |
VGG16ImagePreProcessor.transformLabel(INDArray label) |
void |
ImagePreProcessingScaler.transformLabel(INDArray label) |
void |
DataNormalization.transformLabel(INDArray labels)
Transform the labels.
|
void |
AbstractDataSetNormalizer.transformLabel(INDArray label)
Transform the labels.
|
void |
VGG16ImagePreProcessor.transformLabel(INDArray labels,
INDArray labelsMask) |
void |
ImagePreProcessingScaler.transformLabel(INDArray labels,
INDArray labelsMask) |
void |
DataNormalization.transformLabel(INDArray labels,
INDArray labelsMask)
Transform the labels.
|
void |
AbstractDataSetNormalizer.transformLabel(INDArray label,
INDArray labelsMask) |
| Constructor and Description |
|---|
NormalizerStandardize(INDArray featureMean,
INDArray featureStd) |
NormalizerStandardize(INDArray featureMean,
INDArray featureStd,
INDArray labelMean,
INDArray labelStd) |
| Modifier and Type | Method and Description |
|---|---|
INDArray |
BaseUnderSamplingPreProcessor.adjustMasks(INDArray label,
INDArray labelMask,
int minorityLabel,
double targetDist) |
| Modifier and Type | Method and Description |
|---|---|
INDArray |
BaseUnderSamplingPreProcessor.adjustMasks(INDArray label,
INDArray labelMask,
int minorityLabel,
double targetDist) |
| Modifier and Type | Method and Description |
|---|---|
INDArray |
MinMaxStats.getRange()
Get the feature wise
range for the statistics.
|
| Modifier and Type | Method and Description |
|---|---|
NormalizerStats.Builder<S> |
NormalizerStats.Builder.add(INDArray data,
INDArray mask)
Add rows of data to the statistics
|
MinMaxStats.Builder |
MinMaxStats.Builder.add(INDArray data,
INDArray mask)
Add rows of data to the statistics
|
DistributionStats.Builder |
DistributionStats.Builder.add(INDArray data,
INDArray mask)
Add rows of data to the statistics
|
| Constructor and Description |
|---|
DistributionStats(INDArray mean,
INDArray std) |
MinMaxStats(INDArray lower,
INDArray upper) |
| Modifier and Type | Method and Description |
|---|---|
INDArray |
PCA.convertBackToFeatures(INDArray data)
Take the data that has been transformed to the principal components about the mean and
transform it back into the original feature set.
|
INDArray |
PCA.convertToComponents(INDArray data)
Takes a set of data on each row, with the same number of features as the constructing data
and returns the data in the coordinates of the basis set about the mean.
|
static INDArray[] |
PCA.covarianceMatrix(INDArray in)
Returns the covariance matrix of a data set of many records, each with N features.
|
INDArray |
PCA.generateGaussianSamples(long count)
Generates a set of count random samples with the same variance and mean and eigenvector/values
as the data set used to initialize the PCA object, with same number of features N.
|
INDArray |
PCA.getCovarianceMatrix() |
INDArray |
PCA.getEigenvalues() |
INDArray |
PCA.getEigenvectors() |
INDArray |
PCA.getMean() |
static INDArray |
PCA.pca_factor(INDArray A,
double variance,
boolean normalize)
Calculates pca vectors of a matrix, for a given variance.
|
static INDArray |
PCA.pca_factor(INDArray A,
int nDims,
boolean normalize)
Calculates pca factors of a matrix, for a flags number of reduced features
returns the factors to scale observations
The return is a factor matrix to reduce (normalized) feature sets
|
static INDArray |
PCA.pca(INDArray A,
double variance,
boolean normalize)
Calculates pca reduced value of a matrix, for a given variance.
|
static INDArray |
PCA.pca(INDArray A,
int nDims,
boolean normalize)
Calculates pca vectors of a matrix, for a flags number of reduced features
returns the reduced feature set
The return is a projection of A onto principal nDims components
To use the PCA: assume A is the original feature set
then project A onto a reduced set of features.
|
static INDArray |
PCA.pca2(INDArray in,
double variance)
This method performs a dimensionality reduction, including principal components
that cover a fraction of the total variance of the system.
|
static INDArray[] |
PCA.principalComponents(INDArray cov)
Calculates the principal component vectors and their eigenvalues (lambda) for the covariance matrix.
|
INDArray |
RandomProjection.project(INDArray data)
Create a copy random projection by using matrix product with a random matrix
|
INDArray |
RandomProjection.project(INDArray data,
INDArray result)
Create a copy random projection by using matrix product with a random matrix
|
INDArray |
RandomProjection.projecti(INDArray data)
Create an in-place random projection by using in-place matrix product with a random matrix
|
INDArray |
RandomProjection.projecti(INDArray data,
INDArray result)
Create an in-place random projection by using in-place matrix product with a random matrix
|
INDArray |
PCA.reducedBasis(double variance)
Return a reduced basis set that covers a certain fraction of the variance of the data
|
| Modifier and Type | Method and Description |
|---|---|
INDArray |
PCA.convertBackToFeatures(INDArray data)
Take the data that has been transformed to the principal components about the mean and
transform it back into the original feature set.
|
INDArray |
PCA.convertToComponents(INDArray data)
Takes a set of data on each row, with the same number of features as the constructing data
and returns the data in the coordinates of the basis set about the mean.
|
static INDArray[] |
PCA.covarianceMatrix(INDArray in)
Returns the covariance matrix of a data set of many records, each with N features.
|
double |
PCA.estimateVariance(INDArray data,
int ndims)
Estimate the variance of a single record with reduced # of dimensions.
|
static INDArray |
PCA.pca_factor(INDArray A,
double variance,
boolean normalize)
Calculates pca vectors of a matrix, for a given variance.
|
static INDArray |
PCA.pca_factor(INDArray A,
int nDims,
boolean normalize)
Calculates pca factors of a matrix, for a flags number of reduced features
returns the factors to scale observations
The return is a factor matrix to reduce (normalized) feature sets
|
static INDArray |
PCA.pca(INDArray A,
double variance,
boolean normalize)
Calculates pca reduced value of a matrix, for a given variance.
|
static INDArray |
PCA.pca(INDArray A,
int nDims,
boolean normalize)
Calculates pca vectors of a matrix, for a flags number of reduced features
returns the reduced feature set
The return is a projection of A onto principal nDims components
To use the PCA: assume A is the original feature set
then project A onto a reduced set of features.
|
static INDArray |
PCA.pca2(INDArray in,
double variance)
This method performs a dimensionality reduction, including principal components
that cover a fraction of the total variance of the system.
|
static INDArray[] |
PCA.principalComponents(INDArray cov)
Calculates the principal component vectors and their eigenvalues (lambda) for the covariance matrix.
|
INDArray |
RandomProjection.project(INDArray data)
Create a copy random projection by using matrix product with a random matrix
|
INDArray |
RandomProjection.project(INDArray data,
INDArray result)
Create a copy random projection by using matrix product with a random matrix
|
INDArray |
RandomProjection.projecti(INDArray data)
Create an in-place random projection by using in-place matrix product with a random matrix
|
INDArray |
RandomProjection.projecti(INDArray data,
INDArray result)
Create an in-place random projection by using in-place matrix product with a random matrix
|
protected static long[] |
RandomProjection.targetShape(INDArray X,
double eps)
Compute the target shape of a suitable projection matrix
|
protected static long[] |
RandomProjection.targetShape(INDArray X,
int targetDimension)
Compute the target shape of a suitable projection matrix
|
| Constructor and Description |
|---|
PCA(INDArray dataset)
Create a PCA instance with calculated data: covariance, mean, eigenvectors, and eigenvalues.
|
| Modifier and Type | Field and Description |
|---|---|
static INDArray |
Eigen.dummy |
| Modifier and Type | Method and Description |
|---|---|
static INDArray |
Eigen.symmetricGeneralizedEigenvalues(INDArray A)
Compute generalized eigenvalues of the problem A x = L x.
|
static INDArray |
Eigen.symmetricGeneralizedEigenvalues(INDArray A,
boolean calculateVectors)
Compute generalized eigenvalues of the problem A x = L x.
|
static INDArray |
Eigen.symmetricGeneralizedEigenvalues(INDArray A,
INDArray B)
Compute generalized eigenvalues of the problem A x = L B x.
|
static INDArray |
Eigen.symmetricGeneralizedEigenvalues(INDArray A,
INDArray B,
boolean calculateVectors)
Compute generalized eigenvalues of the problem A x = L B x.
|
| Modifier and Type | Method and Description |
|---|---|
static INDArray |
Eigen.symmetricGeneralizedEigenvalues(INDArray A)
Compute generalized eigenvalues of the problem A x = L x.
|
static INDArray |
Eigen.symmetricGeneralizedEigenvalues(INDArray A,
boolean calculateVectors)
Compute generalized eigenvalues of the problem A x = L x.
|
static INDArray |
Eigen.symmetricGeneralizedEigenvalues(INDArray A,
INDArray B)
Compute generalized eigenvalues of the problem A x = L B x.
|
static INDArray |
Eigen.symmetricGeneralizedEigenvalues(INDArray A,
INDArray B,
boolean calculateVectors)
Compute generalized eigenvalues of the problem A x = L B x.
|
| Modifier and Type | Method and Description |
|---|---|
static INDArray |
Nd4j.accumulate(INDArray... arrays)
This method sums given arrays and stores them to a new array
|
static INDArray |
Nd4j.accumulate(INDArray target,
Collection<INDArray> arrays)
This method sums given arrays and stores them to a given target array
|
INDArray |
NDArrayFactory.accumulate(INDArray target,
INDArray... arrays)
This method sums given arrays to target
|
static INDArray |
Nd4j.accumulate(INDArray target,
INDArray[] arrays)
This method sums given arrays and stores them to a given target array
|
static INDArray |
Broadcast.add(INDArray x,
INDArray y,
INDArray z,
int... dimensions)
Broadcast add op.
|
static INDArray |
Broadcast.amax(INDArray x,
INDArray y,
INDArray z,
int... dimensions)
Broadcast absolute max op.
|
static INDArray |
Broadcast.amin(INDArray x,
INDArray y,
INDArray z,
int... dimensions)
Broadcast absolute min op.
|
static INDArray |
Nd4j.append(INDArray arr,
int padAmount,
double val,
int axis)
Append the given array with the specified value size along a particular axis.
|
INDArray |
NDArrayFactory.appendBias(INDArray... vectors) |
static INDArray |
Nd4j.appendBias(INDArray... vectors) |
INDArray |
BaseNDArrayFactory.appendBias(INDArray... vectors)
Merge the vectors and append a bias.
|
static INDArray |
Nd4j.arange(double end)
Create a 1D array of evenly spaced values between 0 (inclusive) and
end (exclusive)
with a step size of 1
See Nd4j.arange(double, double, double) with begin = 0 and step size 1. |
static INDArray |
Nd4j.arange(double begin,
double end)
Create a 1D array of evenly spaced values between
begin (inclusive) and end (exclusive)
with a step size of 1
See Nd4j.arange(double, double, double) with step size 1. |
INDArray |
NDArrayFactory.arange(double begin,
double end,
double step)
Array of evenly spaced values.
|
static INDArray |
Nd4j.arange(double begin,
double end,
double step)
Create a 1D array of evenly spaced values between
begin (inclusive) and end (exclusive)
with a step size. |
INDArray |
BaseNDArrayFactory.arange(double begin,
double end,
double step)
Array of evenly spaced values.
|
static INDArray |
Nd4j.argMax(INDArray arr,
int... dimension)
Get the maximum values for a dimension.
|
static INDArray |
Nd4j.argMin(INDArray arr,
int... dimension)
See
Nd4j.argMax(INDArray, int...) but return minimum values. |
INDArray |
NDArrayFactory.average(Collection<INDArray> arrays)
This method averages input arrays, and returns averaged array
|
INDArray |
NDArrayFactory.average(INDArray[] arrays)
This method averages input arrays, and returns averaged array
|
INDArray |
NDArrayFactory.average(INDArray target,
Collection<INDArray> arrays)
This method averages input arrays, and returns averaged array
|
INDArray |
NDArrayFactory.average(INDArray target,
INDArray[] arrays)
This method averages input arrays, and returns averaged array
|
static INDArray |
Nd4j.averageAndPropagate(Collection<INDArray> arrays)
This method averages input arrays, and returns averaged array.
|
static INDArray |
Nd4j.averageAndPropagate(INDArray[] arrays)
This method averages input arrays, and returns averaged array.
|
static INDArray |
Nd4j.averageAndPropagate(INDArray target,
Collection<INDArray> arrays)
This method averages input arrays, and returns averaged array.
|
INDArray |
BlasWrapper.axpy(double da,
INDArray dx,
INDArray dy)
Deprecated.
|
INDArray |
BaseBlasWrapper.axpy(double da,
INDArray dx,
INDArray dy) |
INDArray |
BlasWrapper.axpy(float da,
INDArray dx,
INDArray dy)
Deprecated.
|
INDArray |
BaseBlasWrapper.axpy(float da,
INDArray dx,
INDArray dy) |
INDArray |
BlasWrapper.axpy(Number da,
INDArray dx,
INDArray dy)
Compute y <- y + x * alpha
|
INDArray |
BaseBlasWrapper.axpy(Number da,
INDArray dx,
INDArray dy) |
INDArray |
NDArrayFactory.bilinearProducts(INDArray curr,
INDArray in)
Returns a column vector where each entry is the nth bilinear
product of the nth slices of the two tensors.
|
INDArray |
BaseNDArrayFactory.bilinearProducts(INDArray curr,
INDArray in)
Returns a column vector where each entry is the nth bilinear
product of the nth slices of the two tensors.
|
static INDArray |
Nd4j.choice(INDArray source,
INDArray probs,
INDArray target)
This method samples value from Source array to Target,the default random number generator.
|
static INDArray |
Nd4j.choice(INDArray source,
INDArray probs,
INDArray target,
Random rng)
This method samples value from Source array to Target, with probabilites provided in Probs argument
|
static INDArray |
Nd4j.choice(INDArray source,
INDArray probs,
int numSamples)
This method returns new INDArray instance, sampled from Source array with probabilities given in Probs
using the default random number generator.
|
static INDArray |
Nd4j.choice(INDArray source,
INDArray probs,
int numSamples,
Random rng)
This method returns new INDArray instance, sampled from Source array with probabilities given in Probs.
|
INDArray |
NDArrayFactory.concat(int dimension,
INDArray... toConcat)
Concatneate ndarrays along a dimension
|
static INDArray |
Nd4j.concat(int dimension,
INDArray... toConcat)
Concatneate ndarrays along a dimension
|
INDArray |
BaseNDArrayFactory.concat(int dimension,
INDArray... toConcat)
concatenate ndarrays along a dimension
|
INDArray |
NDArrayFactory.convertDataEx(DataTypeEx typeSrc,
INDArray source,
DataTypeEx typeDst) |
INDArray |
BlasWrapper.copy(INDArray x,
INDArray y)
Compute y <- x (copy a matrix)
|
INDArray |
BaseBlasWrapper.copy(INDArray x,
INDArray y) |
static INDArray |
Broadcast.copy(INDArray x,
INDArray y,
INDArray z,
int... dimensions)
Broadcast copy op.
|
static INDArray |
Nd4j.create(boolean[] data)
Create a vector based on a java boolean array.
|
static INDArray |
Nd4j.create(boolean[][] data)
Create 2D boolean array based on java 2d boolean array.
|
static INDArray |
Nd4j.create(boolean[][] data,
long... shape)
Create a boolean array with given shape based on java 2d boolean array.
|
static INDArray |
Nd4j.create(boolean[] data,
long[] shape,
DataType type)
|
static INDArray |
Nd4j.create(boolean[] data,
long[] shape,
long[] strides,
char order,
DataType type)
|
INDArray |
NDArrayFactory.create(boolean[] data,
long[] shape,
long[] stride,
char order,
DataType dataType,
MemoryWorkspace workspace) |
INDArray |
NDArrayFactory.create(boolean[] data,
long[] shape,
long[] stride,
DataType dataType,
MemoryWorkspace workspace) |
static INDArray |
Nd4j.create(byte[] data,
long[] shape,
DataType type)
|
static INDArray |
Nd4j.create(byte[] data,
long[] shape,
long[] strides,
char order,
DataType type)
|
INDArray |
NDArrayFactory.create(byte[] data,
long[] shape,
long[] stride,
char order,
DataType dataType,
MemoryWorkspace workspace) |
INDArray |
NDArrayFactory.create(byte[] data,
long[] shape,
long[] stride,
DataType dataType,
MemoryWorkspace workspace) |
static INDArray |
Nd4j.create(Collection<String> strings,
long... shape) |
INDArray |
NDArrayFactory.create(Collection<String> strings,
long[] shape,
char order) |
static INDArray |
Nd4j.create(Collection<String> strings,
long[] shape,
char order) |
INDArray |
NDArrayFactory.create(DataBuffer data)
Creates a row vector with the data
|
static INDArray |
Nd4j.create(DataBuffer buffer)
Create an array based on the data buffer.
|
static INDArray |
Nd4j.create(DataBuffer data,
int... shape)
Create an array based on the data buffer with given shape.
|
INDArray |
NDArrayFactory.create(DataBuffer data,
int[] shape)
Create an ndrray with the specified shape
|
INDArray |
NDArrayFactory.create(DataBuffer buffer,
int[] shape,
int[] stride,
char order,
long offset) |
INDArray |
BaseNDArrayFactory.create(DataBuffer buffer,
int[] shape,
int[] stride,
char order,
long offset) |
INDArray |
NDArrayFactory.create(DataBuffer data,
int[] shape,
int[] stride,
long offset)
Creates an ndarray with the specified shape
|
static INDArray |
Nd4j.create(DataBuffer data,
int[] shape,
int[] strides,
long offset)
Create an array based on the data buffer with given shape, stride and offset.
|
INDArray |
NDArrayFactory.create(DataBuffer data,
int[] newShape,
int[] newStride,
long offset,
char ordering) |
static INDArray |
Nd4j.create(DataBuffer data,
int[] newShape,
int[] newStride,
long offset,
char ordering)
|
INDArray |
NDArrayFactory.create(DataBuffer buffer,
int[] shape,
long offset) |
static INDArray |
Nd4j.create(DataBuffer data,
int[] shape,
long offset)
|
static INDArray |
Nd4j.create(DataBuffer data,
long... shape)
|
INDArray |
NDArrayFactory.create(DataBuffer data,
long[] shape) |
INDArray |
NDArrayFactory.create(DataBuffer data,
long[] shape,
long[] stride,
long offset) |
static INDArray |
Nd4j.create(DataBuffer data,
long[] shape,
long[] strides,
long offset)
|
INDArray |
NDArrayFactory.create(DataBuffer data,
long[] newShape,
long[] newStride,
long offset,
char ordering) |
static INDArray |
Nd4j.create(DataBuffer data,
long[] newShape,
long[] newStride,
long offset,
char ordering)
|
INDArray |
NDArrayFactory.create(DataBuffer data,
long[] newShape,
long[] newStride,
long offset,
char ordering,
DataType dataType) |
static INDArray |
Nd4j.create(DataBuffer data,
long[] newShape,
long[] newStride,
long offset,
char ordering,
DataType dataType)
Create an array based on the data buffer with given shape, stride, offset and data type.
|
INDArray |
NDArrayFactory.create(DataBuffer data,
long[] newShape,
long[] newStride,
long offset,
long ews,
char ordering) |
static INDArray |
Nd4j.create(DataBuffer data,
long[] newShape,
long[] newStride,
long offset,
long ews,
char ordering)
Create an array based on the data buffer with given shape, stride and offset.
|
INDArray |
NDArrayFactory.create(DataBuffer data,
long rows,
long columns,
int[] stride,
long offset)
Creates an ndarray with the specified shape
|
static INDArray |
Nd4j.create(DataType type,
long... shape)
Create an array with specified shape and datatype.
|
static INDArray |
Nd4j.create(DataType dataType,
long[] shape,
char ordering)
Create an array with given data type shape and ordering.
|
INDArray |
NDArrayFactory.create(DataType dataType,
long[] shape,
char ordering,
MemoryWorkspace workspace) |
static INDArray |
Nd4j.create(DataType dataType,
long[] shape,
long[] strides,
char ordering)
Create an array with given shape, stride and ordering.
|
INDArray |
NDArrayFactory.create(DataType dataType,
long[] shape,
long[] strides,
char ordering,
MemoryWorkspace workspace) |
INDArray |
NDArrayFactory.create(double[] data)
Creates a row vector with the data
|
static INDArray |
Nd4j.create(double[] data)
Create double array based on java double array.
|
INDArray |
BaseNDArrayFactory.create(double[] data)
Creates a row vector with the data
|
INDArray |
NDArrayFactory.create(double[][] data)
Create an ndarray with the given data layout
|
static INDArray |
Nd4j.create(double[][] data)
Create 2D double array based on java 2d double array. and ordering
|
static INDArray |
Nd4j.create(double[][][] data)
Create a 3D double array based on the 3D java double array.
|
static INDArray |
Nd4j.create(double[][][][] data)
Create 4D double array based on 4D java double array.
|
INDArray |
NDArrayFactory.create(double[][] data,
char ordering)
Create a matrix from the given
data and ordering
|
static INDArray |
Nd4j.create(double[][] data,
char ordering)
Create a 2D double array based on a 2D java double array with given ordering.
|
INDArray |
NDArrayFactory.create(double[] data,
char order) |
static INDArray |
Nd4j.create(double[] data,
char order)
Creates a row vector with the data
|
INDArray |
BaseNDArrayFactory.create(double[] data,
char order) |
INDArray |
NDArrayFactory.create(double[] data,
int[] shape)
Create an ndrray with the specified shape
|
static INDArray |
Nd4j.create(double[] data,
int[] shape)
Create an array of the specified shape initialized with values from a java 1d array.
|
INDArray |
BaseNDArrayFactory.create(double[] data,
int[] shape)
Create an ndrray with the specified shape
|
INDArray |
NDArrayFactory.create(double[] data,
int[] shape,
char ordering) |
static INDArray |
Nd4j.create(double[] data,
int[] shape,
char ordering)
Create an array withgiven shape and ordering based on a java double array.
|
INDArray |
NDArrayFactory.create(double[] data,
int[] shape,
int[] stride,
char order,
long offset) |
INDArray |
BaseNDArrayFactory.create(double[] data,
int[] shape,
int[] stride,
char order,
long offset) |
INDArray |
NDArrayFactory.create(double[] data,
int[] shape,
int[] stride,
long offset)
Creates an ndarray with the specified shape
|
abstract INDArray |
BaseNDArrayFactory.create(double[] data,
int[] shape,
int[] stride,
long offset)
Creates an ndarray with the specified shape
|
INDArray |
NDArrayFactory.create(double[] data,
int[] shape,
int[] stride,
long offset,
char ordering) |
INDArray |
NDArrayFactory.create(double[] data,
int[] shape,
long offset) |
static INDArray |
Nd4j.create(double[] data,
int[] shape,
long offset,
char ordering)
Create an array.
|
static INDArray |
Nd4j.create(double[] data,
long... shape)
|
INDArray |
NDArrayFactory.create(double[] data,
long[] shape) |
INDArray |
BaseNDArrayFactory.create(double[] data,
long[] shape) |
INDArray |
NDArrayFactory.create(double[] data,
long[] shape,
char ordering) |
static INDArray |
Nd4j.create(double[] data,
long[] shape,
char ordering)
|
static INDArray |
Nd4j.create(double[] data,
long[] shape,
DataType type)
|
static INDArray |
Nd4j.create(double[] data,
long[] shape,
long[] strides,
char order,
DataType type)
|
INDArray |
NDArrayFactory.create(double[] data,
long[] shape,
long[] stride,
char order,
DataType dataType,
MemoryWorkspace workspace) |
INDArray |
NDArrayFactory.create(double[] data,
long[] shape,
long[] stride,
DataType dataType,
MemoryWorkspace workspace) |
INDArray |
NDArrayFactory.create(double[] data,
long[] shape,
long[] stride,
long offset) |
INDArray |
NDArrayFactory.create(double[] data,
long[] shape,
long[] stride,
long offset,
char ordering) |
static INDArray |
Nd4j.create(double[] data,
long[] shape,
long offset,
char ordering)
|
INDArray |
NDArrayFactory.create(double[] data,
long[] shape,
long offset,
Character order) |
INDArray |
NDArrayFactory.create(double[] data,
long rows,
long columns,
int[] stride,
long offset)
Creates an ndarray with the specified shape
|
INDArray |
BaseNDArrayFactory.create(double[] data,
long rows,
long columns,
int[] stride,
long offset)
Creates an ndarray with the specified shape
|
INDArray |
NDArrayFactory.create(float[] data)
Creates a row vector with the data
|
static INDArray |
Nd4j.create(float[] data)
Creates a row vector with the data
|
INDArray |
BaseNDArrayFactory.create(float[] data)
Creates a row vector with the data
|
INDArray |
NDArrayFactory.create(float[][] floats) |
static INDArray |
Nd4j.create(float[][] data)
Create 2D float array based on java 2d float array.
|
static INDArray |
Nd4j.create(float[][][] data)
Create a 3D float array based on the 3D java float array.
|
static INDArray |
Nd4j.create(float[][][][] data)
Create 4D float array based on 4D java float array.
|
INDArray |
NDArrayFactory.create(float[][] data,
char ordering) |
static INDArray |
Nd4j.create(float[][] data,
char ordering)
Create 2D float array based on java 2d float array and ordering.
|
INDArray |
NDArrayFactory.create(float[] data,
char order) |
static INDArray |
Nd4j.create(float[] data,
char order)
Creates a row vector with the data
|
INDArray |
BaseNDArrayFactory.create(float[] data,
char order) |
INDArray |
NDArrayFactory.create(float[] data,
int[] shape)
Create an ndrray with the specified shape
|
static INDArray |
Nd4j.create(float[] data,
int[] shape)
Create an ndrray with the specified shape
|
INDArray |
BaseNDArrayFactory.create(float[] data,
int[] shape)
Create an ndrray with the specified shape
|
INDArray |
NDArrayFactory.create(float[] data,
int[] shape,
char ordering) |
static INDArray |
Nd4j.create(float[] data,
int[] shape,
char ordering)
|
INDArray |
BaseNDArrayFactory.create(float[] data,
int[] shape,
char ordering) |
INDArray |
NDArrayFactory.create(float[] data,
int[] shape,
int[] stride,
char order,
long offset) |
INDArray |
BaseNDArrayFactory.create(float[] data,
int[] shape,
int[] stride,
char order,
long offset) |
INDArray |
NDArrayFactory.create(float[] data,
int[] shape,
int[] stride,
long offset)
Creates an ndarray with the specified shape
|
static INDArray |
Nd4j.create(float[] data,
int[] shape,
int[] stride,
long offset)
Create an array of the specified type, shape and stride initialized with values from a java 1d array using offset.
|
abstract INDArray |
BaseNDArrayFactory.create(float[] data,
int[] shape,
int[] stride,
long offset)
Creates an ndarray with the specified shape
|
INDArray |
NDArrayFactory.create(float[] data,
int[] shape,
int[] stride,
long offset,
char ordering) |
INDArray |
NDArrayFactory.create(float[] data,
int[] shape,
long offset) |
INDArray |
BaseNDArrayFactory.create(float[] data,
int[] shape,
long offset) |
INDArray |
NDArrayFactory.create(float[] data,
int[] shape,
long offset,
Character order) |
static INDArray |
Nd4j.create(float[] data,
long... shape)
|
INDArray |
NDArrayFactory.create(float[] data,
long[] shape) |
INDArray |
BaseNDArrayFactory.create(float[] data,
long[] shape) |
INDArray |
NDArrayFactory.create(float[] data,
long[] shape,
char ordering) |
static INDArray |
Nd4j.create(float[] data,
long[] shape,
char ordering)
|
static INDArray |
Nd4j.create(float[] data,
long[] shape,
DataType type)
|
INDArray |
NDArrayFactory.create(float[] data,
long[] shape,
long[] stride,
char order,
DataType dataType) |
static INDArray |
Nd4j.create(float[] data,
long[] shape,
long[] strides,
char order,
DataType type)
|
INDArray |
NDArrayFactory.create(float[] data,
long[] shape,
long[] stride,
char order,
DataType dataType,
MemoryWorkspace workspace) |
abstract INDArray |
BaseNDArrayFactory.create(float[] data,
long[] shape,
long[] stride,
char order,
DataType dataType,
MemoryWorkspace workspace) |
INDArray |
NDArrayFactory.create(float[] data,
long[] shape,
long[] stride,
char order,
long offset) |
INDArray |
NDArrayFactory.create(float[] data,
long[] shape,
long[] stride,
DataType dataType,
MemoryWorkspace workspace) |
INDArray |
NDArrayFactory.create(float[] data,
long[] shape,
long[] stride,
long offset) |
INDArray |
NDArrayFactory.create(float[] data,
long[] shape,
long[] stride,
long offset,
char ordering) |
INDArray |
NDArrayFactory.create(float[] data,
long[] shape,
long offset,
Character order) |
INDArray |
NDArrayFactory.create(float[] data,
long rows,
long columns,
int[] stride,
long offset) |
INDArray |
BaseNDArrayFactory.create(float[] data,
long rows,
long columns,
int[] stride,
long offset)
Creates an ndarray with the specified shape
|
INDArray |
NDArrayFactory.create(float[] data,
long rows,
long columns,
int[] stride,
long offset,
char ordering) |
static INDArray |
Nd4j.create(int... shape)
Creates an ndarray with the specified shape
|
static INDArray |
Nd4j.create(int columns)
Creates a row vector with the specified number of columns
|
INDArray |
NDArrayFactory.create(int[] shape)
Creates an ndarray with the specified shape
|
INDArray |
BaseNDArrayFactory.create(int[] shape)
Creates an ndarray with the specified shape
|
static INDArray |
Nd4j.create(int[][][] data)
create 3D int array based on 3D java int array.
|
static INDArray |
Nd4j.create(int[][][][] data)
Create 4D int array based on 4D java int array.
|
INDArray |
NDArrayFactory.create(int[] shape,
char ordering) |
static INDArray |
Nd4j.create(int[] shape,
char ordering)
Creates an ndarray with the specified shape
|
INDArray |
NDArrayFactory.create(int[] shape,
DataBuffer buffer)
Create an ndarray with the given shape
and data
|
static INDArray |
Nd4j.create(int[] shape,
DataType dataType)
Create an array of given shape and data type.
|
INDArray |
NDArrayFactory.create(int[] shape,
DataType dataType,
MemoryWorkspace workspace) |
INDArray |
BaseNDArrayFactory.create(int[] shape,
DataType dataType,
MemoryWorkspace workspace) |
static INDArray |
Nd4j.create(int[] sliceShape,
double[]... arrays)
See
#create(int[], float[]...) |
static INDArray |
Nd4j.create(int[] sliceShape,
float[]... arrays)
Create an ndarray based on the given data
|
INDArray |
NDArrayFactory.create(int[] shape,
int[] stride)
Creates an ndarray with the specified shape
|
static INDArray |
Nd4j.create(int[] shape,
int[] stride)
Creates an ndarray with the specified shape
|
INDArray |
BaseNDArrayFactory.create(int[] shape,
int[] stride)
Creates an ndarray with the specified shape
|
static INDArray |
Nd4j.create(int[] shape,
int[] stride,
char ordering)
Creates an ndarray with the specified shape
|
INDArray |
NDArrayFactory.create(int[] shape,
int[] ints1,
int[] stride,
char order,
long offset) |
INDArray |
BaseNDArrayFactory.create(int[] data,
int[] shape,
int[] stride,
char order,
long offset) |
INDArray |
NDArrayFactory.create(int[] ints,
int[] ints1,
int[] stride,
long offset) |
INDArray |
BaseNDArrayFactory.create(int[] ints,
int[] ints1,
int[] stride,
long offset) |
INDArray |
NDArrayFactory.create(int[] shape,
int[] stride,
long offset)
Creates an ndarray with the specified shape
|
static INDArray |
Nd4j.create(int[] shape,
int[] stride,
long offset)
Creates an ndarray with the specified shape
|
INDArray |
BaseNDArrayFactory.create(int[] shape,
int[] stride,
long offset)
Creates an ndarray with the specified shape
|
INDArray |
NDArrayFactory.create(int[] shape,
int[] stride,
long offset,
char ordering) |
INDArray |
BaseNDArrayFactory.create(int[] shape,
int[] stride,
long offset,
char ordering) |
static INDArray |
Nd4j.create(int[] data,
long[] shape,
DataType type)
Create an array of the specified type and shape initialized with values from a java 1d array.
|
static INDArray |
Nd4j.create(int[] data,
long[] shape,
long[] strides,
char order,
DataType type)
Create an array of the specified type, shape and stride initialized with values from a java 1d array.
|
INDArray |
NDArrayFactory.create(int[] data,
long[] shape,
long[] stride,
char order,
DataType dataType,
MemoryWorkspace workspace) |
INDArray |
NDArrayFactory.create(int[] data,
long[] shape,
long[] stride,
DataType dataType,
MemoryWorkspace workspace) |
static INDArray |
Nd4j.create(int columns,
char order)
Creates a row vector with the specified number of columns
|
static INDArray |
Nd4j.create(int rows,
int columns)
Creates an ndarray with the specified shape
|
static INDArray |
Nd4j.create(int rows,
int columns,
int[] stride)
Creates an ndarray with the specified shape
|
static INDArray |
Nd4j.create(int rows,
int columns,
int[] stride,
char ordering)
Create a 2D array with given rows, columns, stride and ordering.
|
static INDArray |
Nd4j.create(int rows,
int columns,
int[] stride,
long offset)
Creates an ndarray with the specified shape
|
static INDArray |
Nd4j.create(List<? extends Number> list)
Creates a row vector with the data
|
static INDArray |
Nd4j.create(List<INDArray> list,
int... shape)
Creates an array with the specified shape from a list of arrays.
|
INDArray |
NDArrayFactory.create(List<INDArray> list,
int[] shape)
Creates an ndarray with the specified shape
|
abstract INDArray |
BaseNDArrayFactory.create(List<INDArray> list,
int[] shape)
Creates an ndarray with the specified shape
|
INDArray |
NDArrayFactory.create(List<INDArray> list,
int[] shape,
char ordering) |
static INDArray |
Nd4j.create(List<INDArray> list,
long... shape)
|
INDArray |
NDArrayFactory.create(List<INDArray> list,
long[] shape) |
INDArray |
NDArrayFactory.create(List<INDArray> list,
long[] shape,
char ordering) |
static INDArray |
Nd4j.create(long... shape)
Creates an ndarray with the specified shape
|
INDArray |
NDArrayFactory.create(long columns)
Creates a row vector with the specified number of columns
|
INDArray |
BaseNDArrayFactory.create(long columns)
Creates a row vector with the specified number of columns
|
INDArray |
NDArrayFactory.create(long[] shape) |
INDArray |
BaseNDArrayFactory.create(long[] shape)
Creates an ndarray with the specified shape
|
static INDArray |
Nd4j.create(long[][] data)
Create 2D long array based on java 2d long array.
|
INDArray |
NDArrayFactory.create(long[] shape,
char ordering) |
static INDArray |
Nd4j.create(long[] shape,
char ordering)
Create an array with given shape and ordering.
|
INDArray |
NDArrayFactory.create(long[] shape,
long[] stride) |
static INDArray |
Nd4j.create(long[] shape,
long[] stride)
|
INDArray |
BaseNDArrayFactory.create(long[] shape,
long[] stride) |
static INDArray |
Nd4j.create(long[] shape,
long[] stride,
char ordering)
|
static INDArray |
Nd4j.create(long[] data,
long[] shape,
DataType type)
|
INDArray |
NDArrayFactory.create(long[] shape,
long[] stride,
long offset) |
INDArray |
BaseNDArrayFactory.create(long[] shape,
long[] stride,
long offset) |
static INDArray |
Nd4j.create(long[] data,
long[] shape,
long[] strides,
char order,
DataType type)
|
INDArray |
NDArrayFactory.create(long[] data,
long[] shape,
long[] stride,
char order,
DataType dataType,
MemoryWorkspace workspace) |
INDArray |
NDArrayFactory.create(long[] data,
long[] shape,
long[] stride,
DataType dataType,
MemoryWorkspace workspace) |
INDArray |
NDArrayFactory.create(long[] shape,
long[] stride,
long offset,
char ordering) |
static INDArray |
Nd4j.create(long[] shape,
long[] stride,
long offset,
char ordering)
Creates an ndarray with the specified shape
|
INDArray |
BaseNDArrayFactory.create(long[] shape,
long[] stride,
long offset,
char ordering) |
INDArray |
NDArrayFactory.create(long rows,
long columns)
Creates an ndarray with the specified shape
|
INDArray |
BaseNDArrayFactory.create(long rows,
long columns)
Creates an ndarray with the specified shape
|
INDArray |
NDArrayFactory.create(long rows,
long columns,
char ordering) |
static INDArray |
Nd4j.create(long rows,
long columns,
char ordering)
Creates an ndarray with the specified shape
|
INDArray |
BaseNDArrayFactory.create(long rows,
long columns,
char ordering) |
INDArray |
NDArrayFactory.create(long rows,
long columns,
int[] stride)
Creates an ndarray with the specified shape
|
INDArray |
BaseNDArrayFactory.create(long rows,
long columns,
int[] stride)
Creates an ndarray with the specified shape
|
INDArray |
NDArrayFactory.create(long rows,
long columns,
int[] stride,
long offset)
Creates an ndarray with the specified shape
|
INDArray |
BaseNDArrayFactory.create(long rows,
long columns,
int[] stride,
long offset)
Creates an ndarray with the specified shape
|
INDArray |
NDArrayFactory.create(long rows,
long columns,
long[] stride,
long offset) |
static INDArray |
Nd4j.create(LongShapeDescriptor descriptor)
See
Nd4j.create(LongShapeDescriptor, boolean) with initialize set to true. |
static INDArray |
Nd4j.create(LongShapeDescriptor descriptor,
boolean initialize)
Create an ndarray based on the given description,
|
static INDArray |
Nd4j.create(short[] data,
long[] shape,
DataType type)
|
static INDArray |
Nd4j.create(short[] data,
long[] shape,
long[] strides,
char order,
DataType type)
|
INDArray |
NDArrayFactory.create(short[] data,
long[] shape,
long[] stride,
char order,
DataType dataType,
MemoryWorkspace workspace) |
INDArray |
NDArrayFactory.create(short[] data,
long[] shape,
long[] stride,
DataType dataType,
MemoryWorkspace workspace) |
static INDArray |
Nd4j.create(String... strings) |
static INDArray |
Nd4j.createArrayFromShapeBuffer(DataBuffer data,
DataBuffer shapeInfo)
Create array based in data buffer and shape info,
|
static INDArray |
Nd4j.createArrayFromShapeBuffer(DataBuffer data,
Pair<DataBuffer,long[]> shapeInfo)
Create array based in data buffer and shape info,
|
static INDArray |
Nd4j.createFromArray(boolean... array)
This method creates INDArray from provided jvm array
|
static INDArray |
Nd4j.createFromArray(Boolean[] array)
This method creates INDArray from provided jvm array
|
static INDArray |
Nd4j.createFromArray(boolean[][] array)
This method creates INDArray from provided jvm array
|
static INDArray |
Nd4j.createFromArray(Boolean[][] array)
This method creates INDArray from provided jvm array
|
static INDArray |
Nd4j.createFromArray(boolean[][][] array)
This method creates INDArray from provided jvm array
|
static INDArray |
Nd4j.createFromArray(Boolean[][][] array)
This method creates INDArray from provided jvm array
|
static INDArray |
Nd4j.createFromArray(boolean[][][][] array)
This method creates INDArray from provided jvm array
|
static INDArray |
Nd4j.createFromArray(Boolean[][][][] array)
This method creates INDArray from provided jvm array
|
static INDArray |
Nd4j.createFromArray(byte... array)
This method creates INDArray from provided jvm array
|
static INDArray |
Nd4j.createFromArray(Byte[] array)
This method creates INDArray from provided jvm array
|
static INDArray |
Nd4j.createFromArray(byte[][] array)
This method creates INDArray from provided jvm array
|
static INDArray |
Nd4j.createFromArray(Byte[][] array)
This method creates INDArray from provided jvm array
|
static INDArray |
Nd4j.createFromArray(byte[][][] array)
This method creates INDArray from provided jvm array
|
static INDArray |
Nd4j.createFromArray(Byte[][][] array)
This method creates INDArray from provided jvm array
|
static INDArray |
Nd4j.createFromArray(byte[][][][] array)
This method creates INDArray from provided jvm array
|
static INDArray |
Nd4j.createFromArray(Byte[][][][] array)
This method creates INDArray from provided jvm array
|
static INDArray |
Nd4j.createFromArray(double... array)
This method creates INDArray from provided jvm array
|
static INDArray |
Nd4j.createFromArray(Double[] array)
This method creates INDArray from provided jvm array
|
static INDArray |
Nd4j.createFromArray(double[][] array)
This method creates INDArray from provided jvm array
|
static INDArray |
Nd4j.createFromArray(Double[][] array)
This method creates INDArray from provided jvm array
|
static INDArray |
Nd4j.createFromArray(double[][][] array)
This method creates INDArray from provided jvm array
|
static INDArray |
Nd4j.createFromArray(Double[][][] array)
This method creates INDArray from provided jvm array
|
static INDArray |
Nd4j.createFromArray(double[][][][] array)
This method creates INDArray from provided jvm array
|
static INDArray |
Nd4j.createFromArray(Double[][][][] array)
This method creates INDArray from provided jvm array
|
static INDArray |
Nd4j.createFromArray(float... array)
This method creates INDArray from provided jvm array
|
static INDArray |
Nd4j.createFromArray(Float[] array)
This method creates INDArray from provided jvm array
|
static INDArray |
Nd4j.createFromArray(float[][] array)
This method creates INDArray from provided jvm array
|
static INDArray |
Nd4j.createFromArray(Float[][] array)
This method creates INDArray from provided jvm array
|
static INDArray |
Nd4j.createFromArray(float[][][] array)
This method creates INDArray from provided jvm array
|
static INDArray |
Nd4j.createFromArray(Float[][][] array)
This method creates INDArray from provided jvm array
|
static INDArray |
Nd4j.createFromArray(float[][][][] array)
This method creates INDArray from provided jvm array
|
static INDArray |
Nd4j.createFromArray(Float[][][][] array)
This method creates INDArray from provided jvm array
|
static INDArray |
Nd4j.createFromArray(int... array)
This method creates INDArray from provided jvm array
|
static INDArray |
Nd4j.createFromArray(int[][] array)
This method creates INDArray from provided jvm array
|
static INDArray |
Nd4j.createFromArray(int[][][] array)
This method creates INDArray from provided jvm array
|
static INDArray |
Nd4j.createFromArray(int[][][][] array)
This method creates INDArray from provided jvm array
|
static INDArray |
Nd4j.createFromArray(Integer[] array)
This method creates INDArray from provided jvm array
|
static INDArray |
Nd4j.createFromArray(Integer[][] array)
This method creates INDArray from provided jvm array
|
static INDArray |
Nd4j.createFromArray(Integer[][][] array)
This method creates INDArray from provided jvm array
|
static INDArray |
Nd4j.createFromArray(Integer[][][][] array)
This method creates INDArray from provided jvm array
|
static INDArray |
Nd4j.createFromArray(long... array)
This method creates INDArray from provided jvm array
|
static INDArray |
Nd4j.createFromArray(Long[] array)
This method creates INDArray from provided jvm array
|
static INDArray |
Nd4j.createFromArray(long[][] array)
This method creates INDArray from provided jvm array
|
static INDArray |
Nd4j.createFromArray(Long[][] array)
This method creates INDArray from provided jvm array
|
static INDArray |
Nd4j.createFromArray(long[][][] array)
This method creates INDArray from provided jvm array
|
static INDArray |
Nd4j.createFromArray(Long[][][] array)
This method creates INDArray from provided jvm array
|
static INDArray |
Nd4j.createFromArray(long[][][][] array)
This method creates INDArray from provided jvm array
|
static INDArray |
Nd4j.createFromArray(Long[][][][] array)
This method creates INDArray from provided jvm array
|
static INDArray |
Nd4j.createFromArray(short... array)
This method creates INDArray from provided jvm array
|
static INDArray |
Nd4j.createFromArray(Short[] array)
This method creates INDArray from provided jvm array
|
static INDArray |
Nd4j.createFromArray(short[][] array)
This method creates INDArray from provided jvm array
|
static INDArray |
Nd4j.createFromArray(Short[][] array)
This method creates INDArray from provided jvm array
|
static INDArray |
Nd4j.createFromArray(short[][][] array)
This method creates INDArray from provided jvm array
|
static INDArray |
Nd4j.createFromArray(Short[][][] array)
This method creates INDArray from provided jvm array
|
static INDArray |
Nd4j.createFromArray(short[][][][] array)
This method creates INDArray from provided jvm array
|
static INDArray |
Nd4j.createFromArray(Short[][][][] array)
This method creates INDArray from provided jvm array
|
static INDArray |
Nd4j.createFromFlatArray(FlatArray array)
|
INDArray |
NDArrayFactory.createFromNpyFile(File file)
Create from a given numpy file.
|
static INDArray |
Nd4j.createFromNpyFile(File file)
Create an INDArray from a given Numpy .npy file.
|
INDArray |
NDArrayFactory.createFromNpyHeaderPointer(org.bytedeco.javacpp.Pointer pointer)
Create from an in memory numpy header.
|
INDArray |
NDArrayFactory.createFromNpyPointer(org.bytedeco.javacpp.Pointer pointer)
Create from an in memory numpy pointer
|
static INDArray |
Nd4j.createFromNpyPointer(org.bytedeco.javacpp.Pointer pointer)
Create from an in memory numpy pointer
|
static INDArray |
Nd4j.createNpyFromByteArray(byte[] input)
Create an
INDArray from the given numpy input. |
static INDArray |
Nd4j.createNpyFromInputStream(InputStream is)
Create a numpy array based on the passed in input stream
|
static INDArray |
Nd4j.createUninitialized(DataType type,
long... shape) |
static INDArray |
Nd4j.createUninitialized(DataType type,
long[] shape,
char ordering)
Creates an *uninitialized* array with the specified data type, shape and ordering.
|
INDArray |
NDArrayFactory.createUninitialized(DataType dataType,
long[] shape,
char ordering,
MemoryWorkspace workspace) |
static INDArray |
Nd4j.createUninitialized(int... shape)
|
static INDArray |
Nd4j.createUninitialized(int length)
|
INDArray |
NDArrayFactory.createUninitialized(int[] shape,
char ordering) |
static INDArray |
Nd4j.createUninitialized(int[] shape,
char ordering)
Creates an *uninitialized* array with the specified shape and ordering.
|
static INDArray |
Nd4j.createUninitialized(long... shape)
Creates an *uninitialized* ndarray with the specified shape and default ordering.
|
static INDArray |
Nd4j.createUninitialized(long length)
This method creates an *uninitialized* ndarray of specified length and default ordering.
|
INDArray |
NDArrayFactory.createUninitialized(long[] shape,
char ordering) |
static INDArray |
Nd4j.createUninitialized(long[] shape,
char ordering)
Creates an *uninitialized* array with the specified shape and ordering.
|
INDArray |
NDArrayFactory.createUninitializedDetached(DataType dataType,
char ordering,
long... shape)
Create an uninitialized ndArray.
|
static INDArray |
Nd4j.createUninitializedDetached(DataType dataType,
char ordering,
long... shape)
Create an uninitialized ndArray.
|
static INDArray |
Nd4j.createUninitializedDetached(DataType dataType,
long... shape)
See
Nd4j.createUninitializedDetached(DataType, char, long...) with default ordering. |
static INDArray |
Nd4j.cumsum(INDArray compute)
See
cumsum(int) with Integer.MAX_VALUE for full array reduction. |
static INDArray |
Nd4j.cumsum(INDArray compute,
int dimension)
See
cumsum(int) with Integer.MAX_VALUE for full array reduction. |
static INDArray |
Nd4j.diag(INDArray x)
Creates a new matrix where the values of the given vector are the diagonal values of
the matrix if a vector is passed in, if a matrix is returns the kth diagonal
in the matrix
|
static INDArray |
Broadcast.div(INDArray x,
INDArray y,
INDArray z,
int... dimensions)
Broadcast divide op.
|
static INDArray |
Nd4j.empty()
This method creates "empty" INDArray with datatype determined by
Nd4j.dataType() |
INDArray |
NDArrayFactory.empty(DataType type) |
static INDArray |
Nd4j.empty(DataType type)
This method creates "empty" INDArray of the specified datatype
|
static INDArray |
Broadcast.eq(INDArray x,
INDArray y,
INDArray z,
int... dimensions)
Broadcast equal to op.
|
static INDArray[] |
Nd4j.exec(CustomOp op)
Execute the operation and return the result
|
static INDArray[] |
Nd4j.exec(CustomOp op,
OpContext context)
Execute the operation and return the result
|
static INDArray |
Nd4j.exec(Op op)
Execute the operation and return the result
|
static INDArray |
Nd4j.expandDims(INDArray input,
int dimension)
Expand the array dimensions.
|
INDArray |
NDArrayFactory.eye(long n)
Create the identity ndarray
|
static INDArray |
Nd4j.eye(long n)
Create the identity ndarray
|
INDArray |
BaseNDArrayFactory.eye(long n)
Create the identity ndarray
|
static INDArray |
Nd4j.fromByteArray(byte[] arr)
Read an ndarray from a byte array
|
static INDArray |
Nd4j.gemm(INDArray a,
INDArray b,
boolean transposeA,
boolean transposeB)
matrix multiply: implements op(a)*op(b)
where op(x) means transpose x (or not) depending on
setting of arguments transposea and transposeb.
|
static INDArray |
Nd4j.gemm(INDArray a,
INDArray b,
INDArray c,
boolean transposeA,
boolean transposeB,
double alpha,
double beta)
Matrix multiply: Implements c = alpha*op(a)*op(b) + beta*c where op(X) means transpose X (or not)
depending on setting of arguments transposeA and transposeB.
|
INDArray |
BlasWrapper.gemv(double alpha,
INDArray a,
INDArray x,
double beta,
INDArray y)
Deprecated.
|
INDArray |
BaseBlasWrapper.gemv(double alpha,
INDArray a,
INDArray x,
double beta,
INDArray y) |
INDArray |
BlasWrapper.gemv(float alpha,
INDArray a,
INDArray x,
float beta,
INDArray y)
Deprecated.
|
INDArray |
BaseBlasWrapper.gemv(float alpha,
INDArray a,
INDArray x,
float beta,
INDArray y) |
INDArray |
BlasWrapper.gemv(Number alpha,
INDArray a,
INDArray x,
double beta,
INDArray y)
************************************************************************
BLAS Level 2
|
INDArray |
BaseBlasWrapper.gemv(Number alpha,
INDArray a,
INDArray x,
double beta,
INDArray y) |
INDArray |
BlasWrapper.ger(double alpha,
INDArray x,
INDArray y,
INDArray a)
Deprecated.
|
INDArray |
BaseBlasWrapper.ger(double alpha,
INDArray x,
INDArray y,
INDArray a) |
INDArray |
BlasWrapper.ger(float alpha,
INDArray x,
INDArray y,
INDArray a)
Compute A <- alpha * x * y^T + A (general rank-1 update)
|
INDArray |
BaseBlasWrapper.ger(float alpha,
INDArray x,
INDArray y,
INDArray a) |
INDArray |
BlasWrapper.ger(Number alpha,
INDArray x,
INDArray y,
INDArray a) |
INDArray |
BaseBlasWrapper.ger(Number alpha,
INDArray x,
INDArray y,
INDArray a) |
INDArray |
BlasWrapper.gesv(INDArray a,
int[] ipiv,
INDArray b)
************************************************************************
LAPACK
|
INDArray |
BaseBlasWrapper.gesv(INDArray a,
int[] ipiv,
INDArray b) |
static INDArray |
Broadcast.gt(INDArray x,
INDArray y,
INDArray z,
int... dimensions)
Broadcast greater than op.
|
static INDArray |
Broadcast.gte(INDArray x,
INDArray y,
INDArray z,
int... dimensions)
Broadcast greater than or equal to op.
|
static INDArray |
Nd4j.hstack(Collection<INDArray> arrs)
Concatenates two matrices horizontally.
|
INDArray |
NDArrayFactory.hstack(INDArray... arrs)
Concatenates two matrices horizontally.
|
static INDArray |
Nd4j.hstack(INDArray... arrs)
Concatenates two matrices horizontally.
|
INDArray |
BaseNDArrayFactory.hstack(INDArray... arrs)
Concatenates two matrices horizontally.
|
static INDArray |
Nd4j.linspace(DataType dataType,
double lower,
double step,
long num)
Generate a linearly spaced 1d vector of the specified datatype
|
static INDArray |
Nd4j.linspace(DataType dtype,
long lower,
long num,
long step)
Generate a linearly spaced vector
|
static INDArray |
Nd4j.linspace(double lower,
double upper,
long num,
DataType dataType)
Generate a linearly spaced 1d vector of the specified datatype
|
static INDArray |
Nd4j.linspace(long lower,
long upper,
long num)
Generate a linearly spaced vector with default data type
|
static INDArray |
Nd4j.linspace(long lower,
long upper,
long num,
DataType dtype)
Generate a linearly spaced vector
|
static INDArray |
Broadcast.lt(INDArray x,
INDArray y,
INDArray z,
int... dimensions)
Broadcast less than op.
|
static INDArray |
Broadcast.lte(INDArray x,
INDArray y,
INDArray z,
int... dimensions)
Broadcast less than or equal to op.
|
static INDArray |
Nd4j.matmul(INDArray a,
INDArray b)
Matrix multiplication/dot product
See
Nd4j.matmul(INDArray, INDArray, INDArray, boolean, boolean, boolean) |
static INDArray |
Nd4j.matmul(INDArray a,
INDArray b,
boolean transposeA,
boolean transposeB,
boolean transposeResult)
Matrix multiplication/dot product.
|
static INDArray |
Nd4j.matmul(INDArray a,
INDArray b,
INDArray result)
Matrix multiplication/dot product.
|
static INDArray |
Nd4j.matmul(INDArray a,
INDArray b,
INDArray result,
boolean transposeA,
boolean transposeB,
boolean transposeResult)
Matrix multiplication/dot product
Depending on inputs dimensionality output result might be different.
|
static INDArray |
Nd4j.max(INDArray compute)
See
max(int...) with Integer.MAX_VALUE for full array reduction. |
static INDArray |
Broadcast.max(INDArray x,
INDArray y,
INDArray z,
int... dimensions)
Broadcast max op.
|
static INDArray |
Nd4j.max(INDArray compute,
int dimension)
See
max(int...) with Integer.MAX_VALUE for full array reduction. |
static INDArray |
Nd4j.mean(INDArray compute)
See
mean(int...) with Integer.MAX_VALUE for full array reduction. |
static INDArray |
Nd4j.mean(INDArray compute,
int dimension)
See
mean(int...)with Integer.MAX_VALUE for full array reduction. |
static INDArray[] |
Nd4j.meshgrid(INDArray x,
INDArray y)
Meshgrid op.
|
static INDArray |
Nd4j.min(INDArray compute)
See
min(int...) with Integer.MAX_VALUE for full array reduction. |
static INDArray |
Broadcast.min(INDArray x,
INDArray y,
INDArray z,
int... dimensions)
Broadcast min op.
|
static INDArray |
Nd4j.min(INDArray compute,
int dimension)
See
min(int...) with Integer.MAX_VALUE for full array reduction. |
static INDArray |
Broadcast.mul(INDArray x,
INDArray y,
INDArray z,
int... dimensions)
Broadcast element-wise multiply op.
|
static INDArray |
Broadcast.neq(INDArray x,
INDArray y,
INDArray z,
int... dimensions)
Broadcast not equal to op.
|
static INDArray |
Nd4j.norm1(INDArray compute)
See
norm1(int...) with Integer.MAX_VALUE for full array reduction. |
static INDArray |
Nd4j.norm1(INDArray compute,
int dimension)
See
norm1(int...) with Integer.MAX_VALUE for full array reduction. |
static INDArray |
Nd4j.norm2(INDArray compute)
See
norm2(int...) with Integer.MAX_VALUE for full array reduction. |
static INDArray |
Nd4j.norm2(INDArray compute,
int dimension)
See
norm2(int...) with Integer.MAX_VALUE for full array reduction. |
static INDArray |
Nd4j.normmax(INDArray compute)
See
normmax(int...) with Integer.MAX_VALUE for full array reduction. |
static INDArray |
Nd4j.normmax(INDArray compute,
int dimension)
See
normmax(int...) with Integer.MAX_VALUE for full array reduction. |
static INDArray |
Nd4j.ones(DataType dataType,
int rows,
int columns)
Create a 2D array with the given rows, columns and data type initialised with ones.
|
static INDArray |
Nd4j.ones(DataType dataType,
long... shape)
Creates an array with the specified datatype and shape, with values all set to 1
|
static INDArray |
Nd4j.ones(int... shape)
Create an ndarray of ones
|
INDArray |
NDArrayFactory.ones(int[] shape)
Create an ndarray of ones
|
INDArray |
BaseNDArrayFactory.ones(int[] shape)
Create an ndarray of ones
|
static INDArray |
Nd4j.ones(int rows,
int columns)
Creates a row vector with the specified number of columns
|
static INDArray |
Nd4j.ones(long... shape)
|
INDArray |
NDArrayFactory.ones(long columns)
Creates a row vector with the specified number of columns
|
INDArray |
BaseNDArrayFactory.ones(long columns)
Creates a row vector with the specified number of columns
|
INDArray |
NDArrayFactory.ones(long[] shape) |
INDArray |
BaseNDArrayFactory.ones(long[] shape) |
INDArray |
NDArrayFactory.ones(long rows,
long columns)
Creates a row vector with the specified number of columns
|
INDArray |
BaseNDArrayFactory.ones(long rows,
long columns)
Creates a row vector with the specified number of columns
|
static INDArray |
Nd4j.onesLike(INDArray arr)
Ones like
|
static INDArray |
Nd4j.pad(INDArray toPad,
INDArray padding)
See
Nd4j.pad(INDArray, INDArray, Pad.Mode, double) with zero padding (zeros for padValue). |
static INDArray |
Nd4j.pad(INDArray toPad,
INDArray padWidth,
Pad.Mode padMode,
double padValue)
Pad the given ndarray to the size along each dimension.
|
static INDArray |
Nd4j.pad(INDArray toPad,
int... padWidth)
|
static INDArray |
Nd4j.pad(INDArray toPad,
int[][] padWidth)
|
static INDArray |
Nd4j.pad(INDArray toPad,
int[][] padWidth,
Pad.Mode padMode,
double padValue)
See
#pad(INDArray, INDArray, Mode, double). |
static INDArray |
Nd4j.pad(INDArray toPad,
int[] padWidth,
Pad.Mode padMode,
double padValue)
See
#pad(INDArray, INDArray, Mode, double), uses padWidth for all dimensions. |
static INDArray |
Nd4j.pile(Collection<INDArray> arrays)
This method stacks vertically examples with the same shape, increasing result dimensionality.
|
static INDArray |
Nd4j.pile(INDArray... arrays)
This method stacks vertically examples with the same shape, increasing result dimensionality.
|
static INDArray |
Nd4j.prepend(INDArray arr,
int padAmount,
double val,
int axis)
|
static INDArray |
Nd4j.prod(INDArray compute)
See
prod(int...) with Integer.MAX_VALUE for full array reduction. |
static INDArray |
Nd4j.prod(INDArray compute,
int dimension)
See
prod(int...) with Integer.MAX_VALUE for full array reduction. |
static INDArray |
Nd4j.pullRows(INDArray source,
INDArray destination,
int sourceDimension,
int... indexes)
This method produces concatenated array, that consist from tensors, fetched from source array, against some
dimension and specified indexes.
|
INDArray |
NDArrayFactory.pullRows(INDArray source,
INDArray destination,
int sourceDimension,
int[] indexes)
* This method produces concatenated array, that consist from tensors,
fetched from source array, against some dimension and specified indexes
in to the destination array
|
static INDArray |
Nd4j.pullRows(INDArray source,
int sourceDimension,
int... indexes)
This method produces concatenated array, that consist from tensors, fetched from source array, against some dimension and specified indexes
|
INDArray |
NDArrayFactory.pullRows(INDArray source,
int sourceDimension,
int[] indexes)
This method produces concatenated array, that consist from tensors, fetched from source array, against some dimension and specified indexes
|
INDArray |
BaseNDArrayFactory.pullRows(INDArray source,
int sourceDimension,
int[] indexes)
This method produces concatenated array, that consist from tensors, fetched from source array, against some dimension and specified indexes
|
INDArray |
NDArrayFactory.pullRows(INDArray source,
int sourceDimension,
int[] indexes,
char order)
This method produces concatenated array, that consist from tensors,
fetched from source array, against some dimension and specified indexes
|
static INDArray |
Nd4j.pullRows(INDArray source,
int sourceDimension,
int[] indexes,
char order)
This method produces concatenated array,
that consist from tensors,
fetched from source array,
against some dimension and specified indexes
|
INDArray |
BaseNDArrayFactory.pullRows(INDArray source,
int sourceDimension,
int[] indexes,
char order)
This method produces concatenated array, that consist from tensors, fetched from source array, against some dimension and specified indexes
|
INDArray |
NDArrayFactory.pullRows(INDArray source,
int sourceDimension,
long[] indexes) |
static INDArray |
Nd4j.rand(char order,
int... shape)
Create a random ndarray with the given shape and array order
Values are sampled from a uniform distribution over (0, 1)
|
INDArray |
NDArrayFactory.rand(char order,
int[] shape)
Create a random ndarray with the given shape, and specified output order
|
INDArray |
BaseNDArrayFactory.rand(char order,
int[] shape)
Create a random ndarray with the given shape and order
|
INDArray |
NDArrayFactory.rand(char order,
long[] shape)
Create a random ndarray with the given shape
and specified output order
|
INDArray |
BaseNDArrayFactory.rand(char order,
long[] shape) |
INDArray |
NDArrayFactory.rand(char order,
long rows,
long columns)
Create a random (uniform 0-1) NDArray with the specified shape and order
|
INDArray |
BaseNDArrayFactory.rand(char order,
long rows,
long columns)
Create a random (uniform 0-1) NDArray with the specified shape and order
|
static INDArray |
Nd4j.rand(DataType dataType,
char order,
int... shape)
Deprecated.
|
static INDArray |
Nd4j.rand(DataType dataType,
char order,
long... shape)
Create a random ndarray with the given shape, data type, and array order
Values are sampled from a uniform distribution over (0, 1)
|
static INDArray |
Nd4j.rand(DataType dataType,
int... shape)
Create a random ndarray with the given shape and data type
Values are sampled from a uniform distribution over (0, 1)
|
static INDArray |
Nd4j.rand(DataType dataType,
int[] shape,
char order)
Deprecated.
use {@link Nd4j#rand(org.nd4j.linalg.api.buffer.DataType, char, long...))
|
static INDArray |
Nd4j.rand(DataType dataType,
long... shape)
Create a random ndarray with values from a uniform distribution over (0, 1) with the given shape and data type
|
static INDArray |
Nd4j.rand(Distribution dist,
long... shape)
Create a random ndarray with the given shape using the given rng
|
static INDArray |
Nd4j.rand(double min,
double max,
Random rng,
long... shape)
Generates a random matrix between min and max
|
static INDArray |
Nd4j.rand(INDArray target)
Fill the given ndarray with random numbers drawn from a uniform distribution
|
static INDArray |
Nd4j.rand(INDArray target,
Distribution dist)
Fill the given ndarray with random numbers drawn from the given distribution
|
static INDArray |
Nd4j.rand(INDArray target,
double min,
double max,
Random rng)
Fill the given ndarray with random numbers drawn from a uniform distribution using the given RandomGenerator
|
static INDArray |
Nd4j.rand(INDArray target,
long seed)
Fill the given ndarray with random numbers drawn from a uniform distribution
|
static INDArray |
Nd4j.rand(INDArray target,
Random rng)
Fill the given ndarray with random numbers drawn from a uniform distribution using the given RandomGenerator
|
static INDArray |
Nd4j.rand(int... shape)
Create a random ndarray with values from a uniform distribution over (0, 1) with the given shape
|
INDArray |
NDArrayFactory.rand(int[] shape)
Create a random ndarray with the given shape using
the current time as the seed
|
INDArray |
BaseNDArrayFactory.rand(int[] shape)
Create a random ndarray with the given shape using
the current time as the seed
|
INDArray |
NDArrayFactory.rand(int[] shape,
Distribution r)
Create a random ndarray with the given shape using the given rng
|
static INDArray |
Nd4j.rand(int[] shape,
Distribution dist)
|
INDArray |
BaseNDArrayFactory.rand(int[] shape,
Distribution r)
Create a random ndarray with the given shape using the given rng
|
INDArray |
NDArrayFactory.rand(int[] shape,
double min,
double max,
Random rng) |
static INDArray |
Nd4j.rand(int[] shape,
double min,
double max,
Random rng)
|
INDArray |
BaseNDArrayFactory.rand(int[] shape,
double min,
double max,
Random rng) |
INDArray |
NDArrayFactory.rand(int[] shape,
float min,
float max,
Random rng)
Generates a random matrix between min and max
|
INDArray |
BaseNDArrayFactory.rand(int[] shape,
float min,
float max,
Random rng)
Generates a random matrix between min and max
|
INDArray |
NDArrayFactory.rand(int[] shape,
long seed)
Create a random ndarray with the given shape using the given rng
|
static INDArray |
Nd4j.rand(int[] shape,
long seed)
Deprecated.
|
INDArray |
BaseNDArrayFactory.rand(int[] shape,
long seed)
Create a random ndarray with the given shape using the given rng
|
INDArray |
NDArrayFactory.rand(int[] shape,
Random r)
Create a random ndarray with the given shape using the given rng
|
static INDArray |
Nd4j.rand(int[] shape,
Random rng)
Deprecated.
|
INDArray |
BaseNDArrayFactory.rand(int[] shape,
Random r)
Create a random ndarray with the given shape using the given rng
|
static INDArray |
Nd4j.rand(int rows,
int columns,
Random rng)
Create a random ndarray with the given shape using the given rng
|
static INDArray |
Nd4j.rand(long... shape)
See
Nd4j.rand(int[]) |
INDArray |
NDArrayFactory.rand(long[] shape)
Create a random ndarray with the given shape using
the current time as the seed
|
INDArray |
BaseNDArrayFactory.rand(long[] shape) |
static INDArray |
Nd4j.rand(long[] shape,
Distribution dist)
|
INDArray |
NDArrayFactory.rand(long[] shape,
double min,
double max,
Random rng) |
static INDArray |
Nd4j.rand(long[] shape,
double min,
double max,
Random rng)
|
INDArray |
BaseNDArrayFactory.rand(long[] shape,
double min,
double max,
Random rng) |
INDArray |
NDArrayFactory.rand(long[] shape,
float min,
float max,
Random rng) |
INDArray |
BaseNDArrayFactory.rand(long[] shape,
float min,
float max,
Random rng) |
INDArray |
NDArrayFactory.rand(long[] shape,
long seed) |
INDArray |
BaseNDArrayFactory.rand(long[] shape,
long seed) |
INDArray |
NDArrayFactory.rand(long[] shape,
Random r) |
INDArray |
BaseNDArrayFactory.rand(long[] shape,
Random r) |
static INDArray |
Nd4j.rand(long seed,
long... shape)
Create a random ndarray with values from a uniform distribution over (0, 1) with the given shape
using given seed
|
INDArray |
NDArrayFactory.rand(long rows,
long columns)
Create a random ndarray with the given shape using
the current time as the seed
|
INDArray |
BaseNDArrayFactory.rand(long rows,
long columns)
Create a random ndarray with the given shape using
the current time as the seed
|
INDArray |
NDArrayFactory.rand(long rows,
long columns,
double min,
double max,
Random rng) |
INDArray |
BaseNDArrayFactory.rand(long rows,
long columns,
double min,
double max,
Random rng) |
INDArray |
NDArrayFactory.rand(long rows,
long columns,
float min,
float max,
Random rng)
Generates a random matrix between min and max
|
INDArray |
BaseNDArrayFactory.rand(long rows,
long columns,
float min,
float max,
Random rng)
Generates a random matrix between min and max
|
INDArray |
NDArrayFactory.rand(long rows,
long columns,
long seed)
Create a random ndarray with the given shape using the given rng
|
INDArray |
BaseNDArrayFactory.rand(long rows,
long columns,
long seed)
Create a random ndarray with the given shape using the given rng
|
INDArray |
NDArrayFactory.rand(long rows,
long columns,
Random r)
Create a random ndarray with the given shape using the given rng
|
INDArray |
BaseNDArrayFactory.rand(long rows,
long columns,
Random r)
Create a random ndarray with the given shape using the given rng
|
static INDArray |
Nd4j.rand(Random rng,
long... shape)
Create a random ndarray with the given shape using the given RandomGenerator
|
static INDArray |
Nd4j.randn(char order,
int... shape)
Random normal N(0,1) with the specified shape and array order
|
INDArray |
NDArrayFactory.randn(char order,
int[] shape)
Random normal N(0,1) with the specified shape and order
|
INDArray |
BaseNDArrayFactory.randn(char order,
int[] shape)
Random normal using the current time stamp
as the seed
|
static INDArray |
Nd4j.randn(char order,
long... shape)
Random normal N(0,1) with the specified shape and array order
|
INDArray |
NDArrayFactory.randn(char order,
long[] shape)
Random normal N(0,1) with the specified shape and order
|
INDArray |
BaseNDArrayFactory.randn(char order,
long[] shape) |
INDArray |
NDArrayFactory.randn(char order,
long rows,
long columns)
Random normal N(0,1), with specified output order
|
INDArray |
BaseNDArrayFactory.randn(char order,
long rows,
long columns)
Generate a random normal N(0,1) with the specified order and shape
|
static INDArray |
Nd4j.randn(DataType dataType,
char order,
long... shape)
Random normal N(0,1) with the specified shape and array order
|
static INDArray |
Nd4j.randn(DataType dataType,
int[] shape)
Create a ndarray of the given shape and data type with values from N(0,1)
|
static INDArray |
Nd4j.randn(DataType dataType,
long... shape)
Create a ndarray of the given shape and data type with values from N(0,1)
|
static INDArray |
Nd4j.randn(double mean,
double stddev,
INDArray target,
Random rng) |
static INDArray |
Nd4j.randn(double mean,
double stddev,
long[] shape,
Random rng) |
static INDArray |
Nd4j.randn(INDArray target)
Fill the given ndarray with random numbers drawn from a normal distribution
|
static INDArray |
Nd4j.randn(INDArray target,
long seed)
Fill the given ndarray with random numbers drawn from a normal distribution
|
static INDArray |
Nd4j.randn(INDArray target,
Random rng)
Fill the given ndarray with random numbers drawn from a normal distribution utilizing the given random generator
|
INDArray |
NDArrayFactory.randn(int[] shape)
Random normal N(0,1) using the current time stamp
as the seed
|
static INDArray |
Nd4j.randn(int[] shape)
Create a ndarray of the given shape with values from N(0,1)
|
INDArray |
BaseNDArrayFactory.randn(int[] shape)
Random normal N(0,1) with the specified shape and
|
INDArray |
NDArrayFactory.randn(int[] shape,
long seed)
Random normal using the specified seed
|
INDArray |
BaseNDArrayFactory.randn(int[] shape,
long seed)
Random normal using the specified seed
|
INDArray |
NDArrayFactory.randn(int[] shape,
Random r)
Random normal using the given rng
|
static INDArray |
Nd4j.randn(int[] shape,
Random r)
Deprecated.
|
INDArray |
BaseNDArrayFactory.randn(int[] shape,
Random r)
Random normal using the given rng
|
static INDArray |
Nd4j.randn(long... shape)
Create a ndarray of the given shape with values from N(0,1).
|
INDArray |
NDArrayFactory.randn(long[] shape)
Random normal N(0,1) using the current time stamp
as the seed
|
INDArray |
BaseNDArrayFactory.randn(long[] shape) |
INDArray |
NDArrayFactory.randn(long[] shape,
long seed)
Random normal using the specified seed
|
INDArray |
BaseNDArrayFactory.randn(long[] shape,
long seed) |
INDArray |
NDArrayFactory.randn(long[] shape,
Random r) |
static INDArray |
Nd4j.randn(long[] shape,
Random r)
Deprecated.
|
INDArray |
BaseNDArrayFactory.randn(long[] shape,
Random r) |
static INDArray |
Nd4j.randn(long seed,
int[] shape)
Deprecated.
|
INDArray |
NDArrayFactory.randn(long rows,
long columns)
Random normal (N(0,1)) using the current time stamp
as the seed
|
INDArray |
BaseNDArrayFactory.randn(long rows,
long columns)
Random normal using the current time stamp
as the seed
|
static INDArray |
Nd4j.randn(long seed,
long[] shape)
Random normal N(0, 1) using the specified seed
|
INDArray |
NDArrayFactory.randn(long rows,
long columns,
long seed)
Random normal using the specified seed
|
INDArray |
BaseNDArrayFactory.randn(long rows,
long columns,
long seed)
Random normal using the specified seed
|
INDArray |
NDArrayFactory.randn(long rows,
long columns,
Random r)
Random normal using the given rng
|
INDArray |
BaseNDArrayFactory.randn(long rows,
long columns,
Random r)
Random normal using the given rng
|
static INDArray |
Nd4j.randn(Random r,
long... shape)
Random normal using the given rng
|
static INDArray |
Nd4j.randomBernoulli(double p,
INDArray target)
Fill the specified array with values generated according to a binomial distribution with probability p: i.e.,
values 0 with probability (1-p) or value 1 with probability p
|
static INDArray |
Nd4j.randomBernoulli(double p,
long... shape)
Generate a random array according to a binomial distribution with probability p: i.e., values 0 with probability
(1-p) or value 1 with probability p
|
static INDArray |
Nd4j.randomBinomial(int nTrials,
double p,
INDArray target)
Fill the target array with random values generated according to a binomial distribution with the specified
number of trials and probability
|
static INDArray |
Nd4j.randomBinomial(int nTrials,
double p,
long... shape)
Generate an array with random values generated according to a binomial distribution with the specified
number of trials and probability
|
static INDArray |
Nd4j.randomExponential(double lambda,
INDArray target)
Exponential distribution: P(x) = lambda * exp(-lambda * x)
|
static INDArray |
Nd4j.randomExponential(double lambda,
long... shape)
Exponential distribution: P(x) = lambda * exp(-lambda * x)
|
static INDArray |
Broadcast.rdiv(INDArray x,
INDArray y,
INDArray z,
int... dimensions)
Broadcast reverse division op.
|
static INDArray |
Nd4j.read(DataInputStream dis)
Read in an ndarray from a data input stream
|
static INDArray |
Nd4j.read(InputStream reader)
Raad an ndarray from an input stream
See
Nd4j.read(DataInputStream) |
static INDArray |
Nd4j.readBinary(File read)
Read a binary ndarray from the given file
|
static INDArray |
Nd4j.readNpy(File file)
Create an INDArray from a given Numpy .npy file.
|
static INDArray |
Nd4j.readNpy(String path)
Create an INDArray from a given Numpy .npy file.
|
static INDArray |
Nd4j.readNumpy(DataType dataType,
InputStream filePath,
String split,
Charset charset)
Read array from input stream.
|
static INDArray |
Nd4j.readNumpy(DataType dataType,
String filePath)
Read array.
|
static INDArray |
Nd4j.readNumpy(DataType dataType,
String filePath,
String split)
Read array via input stream.
|
static INDArray |
Nd4j.readNumpy(InputStream filePath,
String split)
Read line via input streams
|
static INDArray |
Nd4j.readNumpy(String filePath)
Read line via input streams
|
static INDArray |
Nd4j.readNumpy(String filePath,
String split)
Read line via input streams
|
static INDArray |
Nd4j.readTxt(String filePath)
Read line via input streams
|
static INDArray |
Nd4j.readTxtString(InputStream ndarray)
Read line via input streams
|
static INDArray |
Nd4j.repeat(INDArray n,
int num)
Create an n x (shape)
ndarray where the ndarray is repeated num times
|
INDArray |
NDArrayFactory.reverse(INDArray reverse)
Reverses the passed in matrix such that m[0] becomes m[m.length - 1] etc
|
static INDArray |
Nd4j.reverse(INDArray reverse)
Reverses the passed in matrix such that m[0] becomes m[m.length - 1] etc
|
INDArray |
BaseNDArrayFactory.reverse(INDArray reverse)
Reverses the passed in matrix such that m[0] becomes m[m.length - 1] etc
|
static INDArray |
Nd4j.rollAxis(INDArray a,
int axis)
Roll the specified axis backwards,
until it lies in a given position.
|
static INDArray |
Nd4j.rollAxis(INDArray a,
int axis,
int start)
Roll the specified axis backwards,
until it lies in a given position.
|
INDArray |
NDArrayFactory.rot(INDArray reverse)
Reverses the passed in matrix such that m[0] becomes m[m.length - 1] etc
|
INDArray |
BaseNDArrayFactory.rot(INDArray reverse)
Reverses the passed in matrix such that m[0] becomes m[m.length - 1] etc
|
static INDArray |
Broadcast.rsub(INDArray x,
INDArray y,
INDArray z,
int... dimensions)
Broadcast reverse subtraction op.
|
INDArray |
BlasWrapper.scal(double alpha,
INDArray x)
Deprecated.
|
INDArray |
BaseBlasWrapper.scal(double alpha,
INDArray x) |
INDArray |
BlasWrapper.scal(float alpha,
INDArray x)
Deprecated.
|
INDArray |
BaseBlasWrapper.scal(float alpha,
INDArray x) |
static INDArray |
Nd4j.scalar(boolean value)
Create a scalar NDArray with the specified value and BOOLEAN datatype
|
static INDArray |
Nd4j.scalar(DataType dataType,
Number value)
Create a scalar ndarray with the specified value and datatype
|
INDArray |
NDArrayFactory.scalar(double value)
Create a scalar nd array with the specified value and offset
|
static INDArray |
Nd4j.scalar(double value)
Create a scalar nd array with the specified value
|
INDArray |
BaseNDArrayFactory.scalar(double value)
Create a scalar nd array with the specified value and offset
|
INDArray |
NDArrayFactory.scalar(double value,
long offset)
Create a scalar nd array with the specified value and offset
|
INDArray |
BaseNDArrayFactory.scalar(double value,
long offset)
Create a scalar nd array with the specified value and offset
|
INDArray |
NDArrayFactory.scalar(float value)
Create a scalar nd array with the specified value and offset
|
static INDArray |
Nd4j.scalar(float value)
Create a scalar NDArray with the specified value and FLOAT datatype
|
INDArray |
BaseNDArrayFactory.scalar(float value) |
INDArray |
NDArrayFactory.scalar(float value,
long offset)
Create a scalar nd array with the specified value and offset
|
INDArray |
BaseNDArrayFactory.scalar(float value,
long offset)
Create a scalar nd array with the specified value and offset
|
static INDArray |
Nd4j.scalar(int value)
Create a scalar NDArray with the specified value and INT datatype
|
INDArray |
NDArrayFactory.scalar(int value,
long offset) |
INDArray |
BaseNDArrayFactory.scalar(int value,
long offset)
Create a scalar nd array with the specified value and offset
|
static INDArray |
Nd4j.scalar(long value)
Create a scalar NDArray with the specified value and LONG datatype
|
INDArray |
NDArrayFactory.scalar(Number value)
Create a scalar ndarray with the specified offset
|
static INDArray |
Nd4j.scalar(Number value)
Create a scalar ndarray with the specified value
|
INDArray |
BaseNDArrayFactory.scalar(Number value)
Create a scalar ndarray with the specified offset
|
static INDArray |
Nd4j.scalar(String string) |
INDArray |
NDArrayFactory.sort(INDArray x,
boolean descending) |
static INDArray |
Nd4j.sort(INDArray ndarray,
boolean ascending)
Sort all elements of an array.
|
INDArray |
NDArrayFactory.sort(INDArray x,
boolean descending,
int... dimensions) |
static INDArray |
Nd4j.sort(INDArray ndarray,
int dimension,
boolean ascending)
Sort an ndarray along a particular dimension
Note that the input array is modified in-place. |
static INDArray |
Nd4j.sortColumns(INDArray in,
int rowIdx,
boolean ascending)
Sort (shuffle) the columns of a 2d array according to the value at a specified row.
|
INDArray |
NDArrayFactory.sortCooIndices(INDArray x) |
static INDArray |
Nd4j.sortRows(INDArray in,
int colIdx,
boolean ascending)
Sort (shuffle) the rows of a 2d array according to the value at a specified column.
|
static INDArray[] |
Nd4j.sortWithIndices(INDArray ndarray,
int dimension,
boolean ascending)
Sort an ndarray along a particular dimension.
|
INDArray |
NDArrayFactory.specialConcat(int dimension,
INDArray... toConcat)
Concatenate ndarrays along a dimension
PLEASE NOTE: This method is special for GPU backend, it works on HOST side only.
|
static INDArray |
Nd4j.specialConcat(int dimension,
INDArray... toConcat)
Concatneate ndarrays along a dimension
PLEASE NOTE: This method is special for GPU backend, it works on HOST side only.
|
static INDArray |
Nd4j.squeeze(INDArray input,
int dimension)
Squeeze : removes a dimension of size 1
|
static INDArray |
Nd4j.stack(int axis,
INDArray... values)
Stack a set of N SDVariables of rank X into one rank X+1 variable.
|
static INDArray |
Nd4j.std(INDArray compute)
See
std(int...) with Integer.MAX_VALUE for full array reduction. |
static INDArray |
Nd4j.std(INDArray compute,
int dimension)
See
std(int...) with Integer.MAX_VALUE for full array reduction. |
static INDArray |
Nd4j.stripOnes(INDArray toStrip)
Reshapes an ndarray to remove leading 1s
|
static INDArray |
Broadcast.sub(INDArray x,
INDArray y,
INDArray z,
int... dimensions)
Broadcast subtraction op.
|
static INDArray |
Nd4j.sum(INDArray compute)
See
sum(int...) with Integer.MAX_VALUE for full array reduction. |
static INDArray |
Nd4j.sum(INDArray compute,
int dimension)
See
sum(int...)with Integer.MAX_VALUE for full array reduction. |
INDArray |
BlasWrapper.swap(INDArray x,
INDArray y)
Compute x <-> y (swap two matrices)
|
INDArray |
BaseBlasWrapper.swap(INDArray x,
INDArray y) |
INDArray |
BlasWrapper.sysv(char uplo,
INDArray a,
int[] ipiv,
INDArray b) |
INDArray |
BaseBlasWrapper.sysv(char uplo,
INDArray a,
int[] ipiv,
INDArray b) |
INDArray[] |
NDArrayFactory.tear(INDArray tensor,
int... dimensions) |
static INDArray[] |
Nd4j.tear(INDArray tensor,
int... dimensions)
This method does the opposite to pile/vstack/hstack - it returns independent TAD copies along given dimensions
|
static INDArray |
Nd4j.tensorMmul(INDArray a,
INDArray b,
INDArray result,
int[][] axes)
Tensor matrix multiplication.
|
static INDArray |
Nd4j.tensorMmul(INDArray a,
INDArray b,
int[][] axes)
Tensor matrix multiplication.
|
static INDArray |
Nd4j.tile(INDArray tile,
int... repeat)
An alias for repmat
|
INDArray |
NDArrayFactory.toFlattened(char order,
Collection<INDArray> matrices)
Returns a flattened ndarray with all elements in each ndarray
regardless of dimension.
|
static INDArray |
Nd4j.toFlattened(char order,
Collection<INDArray> matrices)
Create a long row vector of all of the given ndarrays
|
INDArray |
NDArrayFactory.toFlattened(char order,
INDArray... matrices)
Flatten all of the ndarrays in to one long vector
|
static INDArray |
Nd4j.toFlattened(char order,
INDArray... matrices)
Create a long row vector of all of the given ndarrays/
|
INDArray |
BaseNDArrayFactory.toFlattened(char order,
INDArray... matrices) |
INDArray |
NDArrayFactory.toFlattened(Collection<INDArray> matrices)
/**
Returns a flattened ndarray with all of the elements in each ndarray
regardless of dimension
|
static INDArray |
Nd4j.toFlattened(Collection<INDArray> matrices)
Create a long row vector of all of the given ndarrays
|
INDArray |
BaseNDArrayFactory.toFlattened(Collection<INDArray> matrices)
Returns a vector with all of the elements in every nd array
equal to the sum of the lengths of the ndarrays
|
INDArray |
NDArrayFactory.toFlattened(INDArray... matrices)
Flatten all of the ndarrays in to one long vector
|
static INDArray |
Nd4j.toFlattened(INDArray... matrices)
Create a long row vector of all of the given ndarrays
|
INDArray |
BaseNDArrayFactory.toFlattened(INDArray... matrices) |
INDArray |
NDArrayFactory.toFlattened(int length,
Iterator<? extends INDArray>... matrices)
Returns a flattened ndarray with all of the elements in each ndarray
regardless of dimension
|
INDArray |
BaseNDArrayFactory.toFlattened(int length,
Iterator<? extends INDArray>... matrices) |
static INDArray |
Nd4j.tri(int n)
See
Nd4j.tri(int,int,int) with m = n, k=0. |
static INDArray |
Nd4j.tri(int n,
int k)
See
Nd4j.tri(int,int,int) with m = n. |
static INDArray |
Nd4j.tri(int n,
int m,
int k)
Like the scipy function tri.
|
static INDArray |
Nd4j.triu(INDArray m,
int k)
Upper triangle of an array.
|
INDArray |
NDArrayFactory.valueArrayOf(int[] shape,
double value)
Creates an ndarray with the specified value
as the only value in the ndarray
|
static INDArray |
Nd4j.valueArrayOf(int[] shape,
double value)
Creates an ndarray with the specified value
as the only value in the ndarray.
|
INDArray |
BaseNDArrayFactory.valueArrayOf(int[] shape,
double value)
Creates an ndarray with the specified value
as the only value in the ndarray
|
INDArray |
NDArrayFactory.valueArrayOf(long[] shape,
double value) |
static INDArray |
Nd4j.valueArrayOf(long[] shape,
double value)
|
INDArray |
BaseNDArrayFactory.valueArrayOf(long[] shape,
double value) |
static INDArray |
Nd4j.valueArrayOf(long[] shape,
double value,
DataType type)
Creates an ndarray with the specified value
as the only value in the ndarray.
|
static INDArray |
Nd4j.valueArrayOf(long[] shape,
float value)
Creates an ndarray with the specified value as the only value in the FLOAT32 datatype NDArray.
|
static INDArray |
Nd4j.valueArrayOf(long[] shape,
int value)
Creates an ndarray with the specified value as the only value in the INTEGER datatype NDArray.
|
static INDArray |
Nd4j.valueArrayOf(long[] shape,
long value,
DataType type)
|
static INDArray |
Nd4j.valueArrayOf(long num,
double value)
Creates a row vector ndarray with the specified value
as the only value in the ndarray
Some people may know this as np.full
|
INDArray |
NDArrayFactory.valueArrayOf(long rows,
long columns,
double value)
Creates a row vector with the specified number of columns
|
static INDArray |
Nd4j.valueArrayOf(long rows,
long columns,
double value)
Creates a row vector with the specified number of columns
Some people may know this as np.full
|
INDArray |
BaseNDArrayFactory.valueArrayOf(long rows,
long columns,
double value)
Creates a row vector with the specified number of columns
|
static INDArray |
Nd4j.var(INDArray compute)
See
var(int...) with Integer.MAX_VALUE for full array reduction. |
static INDArray |
Nd4j.var(INDArray compute,
int dimension)
See
var(int...) with Integer.MAX_VALUE for full array reduction. |
static INDArray |
Nd4j.vstack(Collection<INDArray> arrs)
Concatenates two matrices vertically.
|
INDArray |
NDArrayFactory.vstack(INDArray... arrs)
Concatenates two matrices vertically.
|
static INDArray |
Nd4j.vstack(INDArray... arrs)
Concatenates two matrices vertically.
|
INDArray |
BaseNDArrayFactory.vstack(INDArray... arrs)
Concatenates two matrices vertically.
|
static INDArray[] |
Nd4j.where(INDArray condition,
INDArray x,
INDArray y)
Similar to numpy.where operation.
|
static INDArray |
Nd4j.zeros(DataType dataType,
int columns)
Creates a 1D array with the specified data tyoe and number of columns initialized with zero.
|
static INDArray |
Nd4j.zeros(DataType dataType,
long... shape)
Creates an array with the specified data tyoe and shape initialized with zero.
|
static INDArray |
Nd4j.zeros(int... shape)
Create an ndarray of zeros
|
static INDArray |
Nd4j.zeros(int columns)
Creates a 1D array with the specified number of columns initialized with zero.
|
INDArray |
NDArrayFactory.zeros(int[] shape)
Create an ndarray of zeros
|
INDArray |
BaseNDArrayFactory.zeros(int[] shape)
Create an ndarray of zeros
|
static INDArray |
Nd4j.zeros(int[] shape,
char order)
Create an ndarray of zeros
|
static INDArray |
Nd4j.zeros(int[] shape,
DataType dataType) |
static INDArray |
Nd4j.zeros(int[] shape,
int[] stride)
|
static INDArray |
Nd4j.zeros(int[] shape,
int[] stride,
long offset)
|
static INDArray |
Nd4j.zeros(int columns,
char order)
Create a 1D float array in soecified order initialized with zero.
|
static INDArray |
Nd4j.zeros(int rows,
int columns,
char ordering)
Create a 2D array initialized with zeros.
|
static INDArray |
Nd4j.zeros(int rows,
int columns,
int[] stride)
See
#create(int, int, int[], char) |
static INDArray |
Nd4j.zeros(int rows,
int columns,
int[] stride,
long offset)
|
static INDArray |
Nd4j.zeros(long... shape)
Create an ndarray of zeros
|
INDArray |
NDArrayFactory.zeros(long columns)
Creates a row vector with the specified number of columns
|
INDArray |
BaseNDArrayFactory.zeros(long columns)
Creates a row vector with the specified number of columns
|
INDArray |
NDArrayFactory.zeros(long[] shape) |
INDArray |
BaseNDArrayFactory.zeros(long[] shape) |
static INDArray |
Nd4j.zeros(long[] shape,
char order)
|
INDArray |
NDArrayFactory.zeros(long rows,
long columns)
Creates a row vector with the specified number of columns
|
static INDArray |
Nd4j.zeros(long rows,
long columns)
Creates a 2D array with specified number of rows, columns initialized with zero.
|
INDArray |
BaseNDArrayFactory.zeros(long rows,
long columns)
Creates a row vector with the specified number of columns
|
static INDArray |
Nd4j.zerosLike(INDArray arr)
Empty like
|
| Modifier and Type | Method and Description |
|---|---|
Map<String,INDArray> |
NDArrayFactory.createFromNpzFile(File file)
Create a Map
|
static Map<String,INDArray> |
Nd4j.createFromNpzFile(File file) |
| Modifier and Type | Method and Description |
|---|---|
static INDArray |
Nd4j.accumulate(INDArray... arrays)
This method sums given arrays and stores them to a new array
|
static INDArray |
Nd4j.accumulate(INDArray target,
Collection<INDArray> arrays)
This method sums given arrays and stores them to a given target array
|
INDArray |
NDArrayFactory.accumulate(INDArray target,
INDArray... arrays)
This method sums given arrays to target
|
INDArray |
NDArrayFactory.accumulate(INDArray target,
INDArray... arrays)
This method sums given arrays to target
|
static INDArray |
Nd4j.accumulate(INDArray target,
INDArray[] arrays)
This method sums given arrays and stores them to a given target array
|
static INDArray |
Nd4j.accumulate(INDArray target,
INDArray[] arrays)
This method sums given arrays and stores them to a given target array
|
static INDArray |
Broadcast.add(INDArray x,
INDArray y,
INDArray z,
int... dimensions)
Broadcast add op.
|
static INDArray |
Broadcast.amax(INDArray x,
INDArray y,
INDArray z,
int... dimensions)
Broadcast absolute max op.
|
static INDArray |
Broadcast.amin(INDArray x,
INDArray y,
INDArray z,
int... dimensions)
Broadcast absolute min op.
|
static INDArray |
Nd4j.append(INDArray arr,
int padAmount,
double val,
int axis)
Append the given array with the specified value size along a particular axis.
|
INDArray |
NDArrayFactory.appendBias(INDArray... vectors) |
static INDArray |
Nd4j.appendBias(INDArray... vectors) |
INDArray |
BaseNDArrayFactory.appendBias(INDArray... vectors)
Merge the vectors and append a bias.
|
static INDArray |
Nd4j.argMax(INDArray arr,
int... dimension)
Get the maximum values for a dimension.
|
static INDArray |
Nd4j.argMin(INDArray arr,
int... dimension)
See
Nd4j.argMax(INDArray, int...) but return minimum values. |
static void |
DataTypeValidation.assertDouble(INDArray... d) |
static void |
DataTypeValidation.assertDouble(INDArray d) |
static void |
DataTypeValidation.assertFloat(INDArray... d2) |
static void |
DataTypeValidation.assertFloat(INDArray d2) |
static void |
DataTypeValidation.assertSameDataType(INDArray... indArrays) |
double |
BlasWrapper.asum(INDArray x)
Compute || x ||_1 (1-norm, sum of absolute values)
|
double |
BaseBlasWrapper.asum(INDArray x) |
INDArray |
NDArrayFactory.average(INDArray[] arrays)
This method averages input arrays, and returns averaged array
|
INDArray |
NDArrayFactory.average(INDArray target,
Collection<INDArray> arrays)
This method averages input arrays, and returns averaged array
|
INDArray |
NDArrayFactory.average(INDArray target,
INDArray[] arrays)
This method averages input arrays, and returns averaged array
|
INDArray |
NDArrayFactory.average(INDArray target,
INDArray[] arrays)
This method averages input arrays, and returns averaged array
|
static INDArray |
Nd4j.averageAndPropagate(INDArray[] arrays)
This method averages input arrays, and returns averaged array.
|
static INDArray |
Nd4j.averageAndPropagate(INDArray target,
Collection<INDArray> arrays)
This method averages input arrays, and returns averaged array.
|
INDArray |
BlasWrapper.axpy(double da,
INDArray dx,
INDArray dy)
Deprecated.
|
INDArray |
BaseBlasWrapper.axpy(double da,
INDArray dx,
INDArray dy) |
INDArray |
BlasWrapper.axpy(float da,
INDArray dx,
INDArray dy)
Deprecated.
|
INDArray |
BaseBlasWrapper.axpy(float da,
INDArray dx,
INDArray dy) |
INDArray |
BlasWrapper.axpy(Number da,
INDArray dx,
INDArray dy)
Compute y <- y + x * alpha
|
INDArray |
BaseBlasWrapper.axpy(Number da,
INDArray dx,
INDArray dy) |
INDArray |
NDArrayFactory.bilinearProducts(INDArray curr,
INDArray in)
Returns a column vector where each entry is the nth bilinear
product of the nth slices of the two tensors.
|
INDArray |
BaseNDArrayFactory.bilinearProducts(INDArray curr,
INDArray in)
Returns a column vector where each entry is the nth bilinear
product of the nth slices of the two tensors.
|
static INDArray |
Nd4j.choice(INDArray source,
INDArray probs,
INDArray target)
This method samples value from Source array to Target,the default random number generator.
|
static INDArray |
Nd4j.choice(INDArray source,
INDArray probs,
INDArray target,
Random rng)
This method samples value from Source array to Target, with probabilites provided in Probs argument
|
static INDArray |
Nd4j.choice(INDArray source,
INDArray probs,
int numSamples)
This method returns new INDArray instance, sampled from Source array with probabilities given in Probs
using the default random number generator.
|
static INDArray |
Nd4j.choice(INDArray source,
INDArray probs,
int numSamples,
Random rng)
This method returns new INDArray instance, sampled from Source array with probabilities given in Probs.
|
static void |
Nd4j.clearNans(INDArray arr)
Clear nans from an ndarray
|
INDArray |
NDArrayFactory.concat(int dimension,
INDArray... toConcat)
Concatneate ndarrays along a dimension
|
static INDArray |
Nd4j.concat(int dimension,
INDArray... toConcat)
Concatneate ndarrays along a dimension
|
INDArray |
BaseNDArrayFactory.concat(int dimension,
INDArray... toConcat)
concatenate ndarrays along a dimension
|
INDArray |
NDArrayFactory.convertDataEx(DataTypeEx typeSrc,
INDArray source,
DataTypeEx typeDst) |
org.bytedeco.javacpp.Pointer |
NDArrayFactory.convertToNumpy(INDArray array)
Convert an
INDArray
to a numpy array. |
static org.bytedeco.javacpp.Pointer |
Nd4j.convertToNumpy(INDArray arr)
Converts an
INDArray to a numpy struct. |
void |
NDArrayFactory.copy(INDArray a,
INDArray b)
Copy a to b
|
static void |
Nd4j.copy(INDArray a,
INDArray b)
Copy a to b
|
INDArray |
BlasWrapper.copy(INDArray x,
INDArray y)
Compute y <- x (copy a matrix)
|
void |
BaseNDArrayFactory.copy(INDArray a,
INDArray b)
Copy a to b
|
INDArray |
BaseBlasWrapper.copy(INDArray x,
INDArray y) |
static INDArray |
Broadcast.copy(INDArray x,
INDArray y,
INDArray z,
int... dimensions)
Broadcast copy op.
|
static INDArray |
Nd4j.cumsum(INDArray compute)
See
cumsum(int) with Integer.MAX_VALUE for full array reduction. |
static INDArray |
Nd4j.cumsum(INDArray compute,
int dimension)
See
cumsum(int) with Integer.MAX_VALUE for full array reduction. |
static INDArray |
Nd4j.diag(INDArray x)
Creates a new matrix where the values of the given vector are the diagonal values of
the matrix if a vector is passed in, if a matrix is returns the kth diagonal
in the matrix
|
static INDArray |
Broadcast.div(INDArray x,
INDArray y,
INDArray z,
int... dimensions)
Broadcast divide op.
|
double |
BlasWrapper.dot(INDArray x,
INDArray y)
Compute x^T * y (dot product)
|
double |
BaseBlasWrapper.dot(INDArray x,
INDArray y) |
static INDArray |
Broadcast.eq(INDArray x,
INDArray y,
INDArray z,
int... dimensions)
Broadcast equal to op.
|
static INDArray |
Nd4j.expandDims(INDArray input,
int dimension)
Expand the array dimensions.
|
int |
BlasWrapper.geev(char jobvl,
char jobvr,
INDArray A,
INDArray WR,
INDArray WI,
INDArray VL,
INDArray VR) |
int |
BaseBlasWrapper.geev(char jobvl,
char jobvr,
INDArray A,
INDArray WR,
INDArray WI,
INDArray VL,
INDArray VR) |
void |
BlasWrapper.gelsd(INDArray A,
INDArray B)
Generalized Least Squares via *GELSD.
|
void |
BaseBlasWrapper.gelsd(INDArray A,
INDArray B) |
static INDArray |
Nd4j.gemm(INDArray a,
INDArray b,
boolean transposeA,
boolean transposeB)
matrix multiply: implements op(a)*op(b)
where op(x) means transpose x (or not) depending on
setting of arguments transposea and transposeb.
|
static INDArray |
Nd4j.gemm(INDArray a,
INDArray b,
INDArray c,
boolean transposeA,
boolean transposeB,
double alpha,
double beta)
Matrix multiply: Implements c = alpha*op(a)*op(b) + beta*c where op(X) means transpose X (or not)
depending on setting of arguments transposeA and transposeB.
|
INDArray |
BlasWrapper.gemv(double alpha,
INDArray a,
INDArray x,
double beta,
INDArray y)
Deprecated.
|
INDArray |
BaseBlasWrapper.gemv(double alpha,
INDArray a,
INDArray x,
double beta,
INDArray y) |
INDArray |
BlasWrapper.gemv(float alpha,
INDArray a,
INDArray x,
float beta,
INDArray y)
Deprecated.
|
INDArray |
BaseBlasWrapper.gemv(float alpha,
INDArray a,
INDArray x,
float beta,
INDArray y) |
INDArray |
BlasWrapper.gemv(Number alpha,
INDArray a,
INDArray x,
double beta,
INDArray y)
************************************************************************
BLAS Level 2
|
INDArray |
BaseBlasWrapper.gemv(Number alpha,
INDArray a,
INDArray x,
double beta,
INDArray y) |
void |
BlasWrapper.geqrf(INDArray A,
INDArray tau) |
void |
BaseBlasWrapper.geqrf(INDArray A,
INDArray tau) |
INDArray |
BlasWrapper.ger(double alpha,
INDArray x,
INDArray y,
INDArray a)
Deprecated.
|
INDArray |
BaseBlasWrapper.ger(double alpha,
INDArray x,
INDArray y,
INDArray a) |
INDArray |
BlasWrapper.ger(float alpha,
INDArray x,
INDArray y,
INDArray a)
Compute A <- alpha * x * y^T + A (general rank-1 update)
|
INDArray |
BaseBlasWrapper.ger(float alpha,
INDArray x,
INDArray y,
INDArray a) |
INDArray |
BlasWrapper.ger(Number alpha,
INDArray x,
INDArray y,
INDArray a) |
INDArray |
BaseBlasWrapper.ger(Number alpha,
INDArray x,
INDArray y,
INDArray a) |
INDArray |
BlasWrapper.gesv(INDArray a,
int[] ipiv,
INDArray b)
************************************************************************
LAPACK
|
INDArray |
BaseBlasWrapper.gesv(INDArray a,
int[] ipiv,
INDArray b) |
static INDArray |
Broadcast.gt(INDArray x,
INDArray y,
INDArray z,
int... dimensions)
Broadcast greater than op.
|
static INDArray |
Broadcast.gte(INDArray x,
INDArray y,
INDArray z,
int... dimensions)
Broadcast greater than or equal to op.
|
INDArray |
NDArrayFactory.hstack(INDArray... arrs)
Concatenates two matrices horizontally.
|
static INDArray |
Nd4j.hstack(INDArray... arrs)
Concatenates two matrices horizontally.
|
INDArray |
BaseNDArrayFactory.hstack(INDArray... arrs)
Concatenates two matrices horizontally.
|
int |
BlasWrapper.iamax(INDArray x)
Compute index of element with largest absolute value (index of absolute
value maximum)
|
int |
BaseBlasWrapper.iamax(INDArray x) |
static boolean |
NDValidation.isSameType(INDArray x,
INDArray y) |
static INDArray |
Broadcast.lt(INDArray x,
INDArray y,
INDArray z,
int... dimensions)
Broadcast less than op.
|
static INDArray |
Broadcast.lte(INDArray x,
INDArray y,
INDArray z,
int... dimensions)
Broadcast less than or equal to op.
|
static INDArray |
Nd4j.matmul(INDArray a,
INDArray b)
Matrix multiplication/dot product
See
Nd4j.matmul(INDArray, INDArray, INDArray, boolean, boolean, boolean) |
static INDArray |
Nd4j.matmul(INDArray a,
INDArray b,
boolean transposeA,
boolean transposeB,
boolean transposeResult)
Matrix multiplication/dot product.
|
static INDArray |
Nd4j.matmul(INDArray a,
INDArray b,
INDArray result)
Matrix multiplication/dot product.
|
static INDArray |
Nd4j.matmul(INDArray a,
INDArray b,
INDArray result,
boolean transposeA,
boolean transposeB,
boolean transposeResult)
Matrix multiplication/dot product
Depending on inputs dimensionality output result might be different.
|
static INDArray |
Nd4j.max(INDArray compute)
See
max(int...) with Integer.MAX_VALUE for full array reduction. |
static INDArray |
Broadcast.max(INDArray x,
INDArray y,
INDArray z,
int... dimensions)
Broadcast max op.
|
static INDArray |
Nd4j.max(INDArray compute,
int dimension)
See
max(int...) with Integer.MAX_VALUE for full array reduction. |
static INDArray |
Nd4j.mean(INDArray compute)
See
mean(int...) with Integer.MAX_VALUE for full array reduction. |
static INDArray |
Nd4j.mean(INDArray compute,
int dimension)
See
mean(int...)with Integer.MAX_VALUE for full array reduction. |
static INDArray[] |
Nd4j.meshgrid(INDArray x,
INDArray y)
Meshgrid op.
|
static INDArray |
Nd4j.min(INDArray compute)
See
min(int...) with Integer.MAX_VALUE for full array reduction. |
static INDArray |
Broadcast.min(INDArray x,
INDArray y,
INDArray z,
int... dimensions)
Broadcast min op.
|
static INDArray |
Nd4j.min(INDArray compute,
int dimension)
See
min(int...) with Integer.MAX_VALUE for full array reduction. |
static INDArray |
Broadcast.mul(INDArray x,
INDArray y,
INDArray z,
int... dimensions)
Broadcast element-wise multiply op.
|
static INDArray |
Broadcast.neq(INDArray x,
INDArray y,
INDArray z,
int... dimensions)
Broadcast not equal to op.
|
static INDArray |
Nd4j.norm1(INDArray compute)
See
norm1(int...) with Integer.MAX_VALUE for full array reduction. |
static INDArray |
Nd4j.norm1(INDArray compute,
int dimension)
See
norm1(int...) with Integer.MAX_VALUE for full array reduction. |
static INDArray |
Nd4j.norm2(INDArray compute)
See
norm2(int...) with Integer.MAX_VALUE for full array reduction. |
static INDArray |
Nd4j.norm2(INDArray compute,
int dimension)
See
norm2(int...) with Integer.MAX_VALUE for full array reduction. |
static INDArray |
Nd4j.normmax(INDArray compute)
See
normmax(int...) with Integer.MAX_VALUE for full array reduction. |
static INDArray |
Nd4j.normmax(INDArray compute,
int dimension)
See
normmax(int...) with Integer.MAX_VALUE for full array reduction. |
double |
BlasWrapper.nrm2(INDArray x)
Compute || x ||_2 (2-norm)
|
double |
BaseBlasWrapper.nrm2(INDArray x) |
static INDArray |
Nd4j.onesLike(INDArray arr)
Ones like
|
void |
BlasWrapper.ormqr(char side,
char trans,
INDArray A,
INDArray tau,
INDArray C) |
void |
BaseBlasWrapper.ormqr(char side,
char trans,
INDArray A,
INDArray tau,
INDArray C) |
static INDArray |
Nd4j.pad(INDArray toPad,
INDArray padding)
See
Nd4j.pad(INDArray, INDArray, Pad.Mode, double) with zero padding (zeros for padValue). |
static INDArray |
Nd4j.pad(INDArray toPad,
INDArray padWidth,
Pad.Mode padMode,
double padValue)
Pad the given ndarray to the size along each dimension.
|
static INDArray |
Nd4j.pad(INDArray toPad,
int... padWidth)
|
static INDArray |
Nd4j.pad(INDArray toPad,
int[][] padWidth)
|
static INDArray |
Nd4j.pad(INDArray toPad,
int[][] padWidth,
Pad.Mode padMode,
double padValue)
See
#pad(INDArray, INDArray, Mode, double). |
static INDArray |
Nd4j.pad(INDArray toPad,
int[] padWidth,
Pad.Mode padMode,
double padValue)
See
#pad(INDArray, INDArray, Mode, double), uses padWidth for all dimensions. |
static INDArray |
Nd4j.pile(INDArray... arrays)
This method stacks vertically examples with the same shape, increasing result dimensionality.
|
void |
BlasWrapper.posv(char uplo,
INDArray A,
INDArray B) |
void |
BaseBlasWrapper.posv(char uplo,
INDArray A,
INDArray B) |
static INDArray |
Nd4j.prepend(INDArray arr,
int padAmount,
double val,
int axis)
|
static INDArray |
Nd4j.prod(INDArray compute)
See
prod(int...) with Integer.MAX_VALUE for full array reduction. |
static INDArray |
Nd4j.prod(INDArray compute,
int dimension)
See
prod(int...) with Integer.MAX_VALUE for full array reduction. |
static INDArray |
Nd4j.pullRows(INDArray source,
INDArray destination,
int sourceDimension,
int... indexes)
This method produces concatenated array, that consist from tensors, fetched from source array, against some
dimension and specified indexes.
|
INDArray |
NDArrayFactory.pullRows(INDArray source,
INDArray destination,
int sourceDimension,
int[] indexes)
* This method produces concatenated array, that consist from tensors,
fetched from source array, against some dimension and specified indexes
in to the destination array
|
static INDArray |
Nd4j.pullRows(INDArray source,
int sourceDimension,
int... indexes)
This method produces concatenated array, that consist from tensors, fetched from source array, against some dimension and specified indexes
|
INDArray |
NDArrayFactory.pullRows(INDArray source,
int sourceDimension,
int[] indexes)
This method produces concatenated array, that consist from tensors, fetched from source array, against some dimension and specified indexes
|
INDArray |
BaseNDArrayFactory.pullRows(INDArray source,
int sourceDimension,
int[] indexes)
This method produces concatenated array, that consist from tensors, fetched from source array, against some dimension and specified indexes
|
INDArray |
NDArrayFactory.pullRows(INDArray source,
int sourceDimension,
int[] indexes,
char order)
This method produces concatenated array, that consist from tensors,
fetched from source array, against some dimension and specified indexes
|
static INDArray |
Nd4j.pullRows(INDArray source,
int sourceDimension,
int[] indexes,
char order)
This method produces concatenated array,
that consist from tensors,
fetched from source array,
against some dimension and specified indexes
|
INDArray |
BaseNDArrayFactory.pullRows(INDArray source,
int sourceDimension,
int[] indexes,
char order)
This method produces concatenated array, that consist from tensors, fetched from source array, against some dimension and specified indexes
|
INDArray |
NDArrayFactory.pullRows(INDArray source,
int sourceDimension,
long[] indexes) |
static INDArray |
Nd4j.rand(INDArray target)
Fill the given ndarray with random numbers drawn from a uniform distribution
|
static INDArray |
Nd4j.rand(INDArray target,
Distribution dist)
Fill the given ndarray with random numbers drawn from the given distribution
|
static INDArray |
Nd4j.rand(INDArray target,
double min,
double max,
Random rng)
Fill the given ndarray with random numbers drawn from a uniform distribution using the given RandomGenerator
|
static INDArray |
Nd4j.rand(INDArray target,
long seed)
Fill the given ndarray with random numbers drawn from a uniform distribution
|
static INDArray |
Nd4j.rand(INDArray target,
Random rng)
Fill the given ndarray with random numbers drawn from a uniform distribution using the given RandomGenerator
|
static INDArray |
Nd4j.randn(double mean,
double stddev,
INDArray target,
Random rng) |
static INDArray |
Nd4j.randn(INDArray target)
Fill the given ndarray with random numbers drawn from a normal distribution
|
static INDArray |
Nd4j.randn(INDArray target,
long seed)
Fill the given ndarray with random numbers drawn from a normal distribution
|
static INDArray |
Nd4j.randn(INDArray target,
Random rng)
Fill the given ndarray with random numbers drawn from a normal distribution utilizing the given random generator
|
static INDArray |
Nd4j.randomBernoulli(double p,
INDArray target)
Fill the specified array with values generated according to a binomial distribution with probability p: i.e.,
values 0 with probability (1-p) or value 1 with probability p
|
static INDArray |
Nd4j.randomBinomial(int nTrials,
double p,
INDArray target)
Fill the target array with random values generated according to a binomial distribution with the specified
number of trials and probability
|
static INDArray |
Nd4j.randomExponential(double lambda,
INDArray target)
Exponential distribution: P(x) = lambda * exp(-lambda * x)
|
static INDArray |
Broadcast.rdiv(INDArray x,
INDArray y,
INDArray z,
int... dimensions)
Broadcast reverse division op.
|
static INDArray |
Nd4j.repeat(INDArray n,
int num)
Create an n x (shape)
ndarray where the ndarray is repeated num times
|
INDArray |
NDArrayFactory.reverse(INDArray reverse)
Reverses the passed in matrix such that m[0] becomes m[m.length - 1] etc
|
static INDArray |
Nd4j.reverse(INDArray reverse)
Reverses the passed in matrix such that m[0] becomes m[m.length - 1] etc
|
INDArray |
BaseNDArrayFactory.reverse(INDArray reverse)
Reverses the passed in matrix such that m[0] becomes m[m.length - 1] etc
|
static INDArray |
Nd4j.rollAxis(INDArray a,
int axis)
Roll the specified axis backwards,
until it lies in a given position.
|
static INDArray |
Nd4j.rollAxis(INDArray a,
int axis,
int start)
Roll the specified axis backwards,
until it lies in a given position.
|
INDArray |
NDArrayFactory.rot(INDArray reverse)
Reverses the passed in matrix such that m[0] becomes m[m.length - 1] etc
|
INDArray |
BaseNDArrayFactory.rot(INDArray reverse)
Reverses the passed in matrix such that m[0] becomes m[m.length - 1] etc
|
void |
NDArrayFactory.rot90(INDArray toRotate)
Rotate a matrix 90 degrees
|
static void |
Nd4j.rot90(INDArray toRotate)
Rotate a matrix 90 degrees
|
void |
BaseNDArrayFactory.rot90(INDArray toRotate)
Rotate a matrix 90 degrees
|
static INDArray |
Broadcast.rsub(INDArray x,
INDArray y,
INDArray z,
int... dimensions)
Broadcast reverse subtraction op.
|
static void |
Nd4j.saveBinary(INDArray arr,
File saveTo)
Save an ndarray to the given file
|
void |
BlasWrapper.saxpy(double alpha,
INDArray x,
INDArray y)
Deprecated.
|
void |
BaseBlasWrapper.saxpy(double alpha,
INDArray x,
INDArray y) |
void |
BlasWrapper.saxpy(float alpha,
INDArray x,
INDArray y)
Deprecated.
|
void |
BaseBlasWrapper.saxpy(float alpha,
INDArray x,
INDArray y) |
INDArray |
BlasWrapper.scal(double alpha,
INDArray x)
Deprecated.
|
INDArray |
BaseBlasWrapper.scal(double alpha,
INDArray x) |
INDArray |
BlasWrapper.scal(float alpha,
INDArray x)
Deprecated.
|
INDArray |
BaseBlasWrapper.scal(float alpha,
INDArray x) |
static void |
Nd4j.scatterUpdate(ScatterUpdate.UpdateOp op,
INDArray array,
INDArray indices,
INDArray updates,
int... axis)
Deprecated.
|
static long[] |
Nd4j.shape(INDArray arr)
Returns the shape of the ndarray
|
static void |
Nd4j.shuffle(INDArray toShuffle,
int... dimension)
In place shuffle of an ndarray
along a specified set of dimensions
|
void |
NDArrayFactory.shuffle(INDArray array,
Random rnd,
int... dimension)
In place shuffle of an ndarray
along a specified set of dimensions
|
static void |
Nd4j.shuffle(INDArray toShuffle,
Random random,
int... dimension)
In place shuffle of an ndarray
along a specified set of dimensions
|
INDArray |
NDArrayFactory.sort(INDArray x,
boolean descending) |
static INDArray |
Nd4j.sort(INDArray ndarray,
boolean ascending)
Sort all elements of an array.
|
INDArray |
NDArrayFactory.sort(INDArray x,
boolean descending,
int... dimensions) |
static INDArray |
Nd4j.sort(INDArray ndarray,
int dimension,
boolean ascending)
Sort an ndarray along a particular dimension
Note that the input array is modified in-place. |
static INDArray |
Nd4j.sortColumns(INDArray in,
int rowIdx,
boolean ascending)
Sort (shuffle) the columns of a 2d array according to the value at a specified row.
|
INDArray |
NDArrayFactory.sortCooIndices(INDArray x) |
static INDArray |
Nd4j.sortRows(INDArray in,
int colIdx,
boolean ascending)
Sort (shuffle) the rows of a 2d array according to the value at a specified column.
|
static INDArray[] |
Nd4j.sortWithIndices(INDArray ndarray,
int dimension,
boolean ascending)
Sort an ndarray along a particular dimension.
|
INDArray |
NDArrayFactory.specialConcat(int dimension,
INDArray... toConcat)
Concatenate ndarrays along a dimension
PLEASE NOTE: This method is special for GPU backend, it works on HOST side only.
|
static INDArray |
Nd4j.specialConcat(int dimension,
INDArray... toConcat)
Concatneate ndarrays along a dimension
PLEASE NOTE: This method is special for GPU backend, it works on HOST side only.
|
static INDArray |
Nd4j.squeeze(INDArray input,
int dimension)
Squeeze : removes a dimension of size 1
|
static INDArray |
Nd4j.stack(int axis,
INDArray... values)
Stack a set of N SDVariables of rank X into one rank X+1 variable.
|
static INDArray |
Nd4j.std(INDArray compute)
See
std(int...) with Integer.MAX_VALUE for full array reduction. |
static INDArray |
Nd4j.std(INDArray compute,
int dimension)
See
std(int...) with Integer.MAX_VALUE for full array reduction. |
static INDArray |
Nd4j.stripOnes(INDArray toStrip)
Reshapes an ndarray to remove leading 1s
|
static INDArray |
Broadcast.sub(INDArray x,
INDArray y,
INDArray z,
int... dimensions)
Broadcast subtraction op.
|
static INDArray |
Nd4j.sum(INDArray compute)
See
sum(int...) with Integer.MAX_VALUE for full array reduction. |
static INDArray |
Nd4j.sum(INDArray compute,
int dimension)
See
sum(int...)with Integer.MAX_VALUE for full array reduction. |
INDArray |
BlasWrapper.swap(INDArray x,
INDArray y)
Compute x <-> y (swap two matrices)
|
INDArray |
BaseBlasWrapper.swap(INDArray x,
INDArray y) |
int |
BlasWrapper.syev(char jobz,
char uplo,
INDArray a,
INDArray w) |
int |
BaseBlasWrapper.syev(char jobz,
char uplo,
INDArray a,
INDArray w) |
int |
BlasWrapper.syevd(char jobz,
char uplo,
INDArray A,
INDArray w) |
int |
BaseBlasWrapper.syevd(char jobz,
char uplo,
INDArray A,
INDArray w) |
int |
BlasWrapper.syevr(char jobz,
char range,
char uplo,
INDArray a,
double vl,
double vu,
int il,
int iu,
double abstol,
INDArray w,
INDArray z,
int[] isuppz)
Deprecated.
|
int |
BaseBlasWrapper.syevr(char jobz,
char range,
char uplo,
INDArray a,
double vl,
double vu,
int il,
int iu,
double abstol,
INDArray w,
INDArray z,
int[] isuppz) |
int |
BlasWrapper.syevr(char jobz,
char range,
char uplo,
INDArray a,
float vl,
float vu,
int il,
int iu,
float abstol,
INDArray w,
INDArray z,
int[] isuppz)
Deprecated.
|
int |
BaseBlasWrapper.syevr(char jobz,
char range,
char uplo,
INDArray a,
float vl,
float vu,
int il,
int iu,
float abstol,
INDArray w,
INDArray z,
int[] isuppz) |
int |
BlasWrapper.syevr(char jobz,
char range,
char uplo,
INDArray a,
float vl,
float vu,
int il,
int iu,
Number abstol,
INDArray w,
INDArray z,
int[] isuppz) |
int |
BaseBlasWrapper.syevr(char jobz,
char range,
char uplo,
INDArray a,
float vl,
float vu,
int il,
int iu,
Number abstol,
INDArray w,
INDArray z,
int[] isuppz) |
int |
BlasWrapper.syevx(char jobz,
char range,
char uplo,
INDArray a,
double vl,
double vu,
int il,
int iu,
double abstol,
INDArray w,
INDArray z) |
int |
BaseBlasWrapper.syevx(char jobz,
char range,
char uplo,
INDArray a,
double vl,
double vu,
int il,
int iu,
double abstol,
INDArray w,
INDArray z) |
int |
BlasWrapper.syevx(char jobz,
char range,
char uplo,
INDArray a,
float vl,
float vu,
int il,
int iu,
float abstol,
INDArray w,
INDArray z) |
int |
BaseBlasWrapper.syevx(char jobz,
char range,
char uplo,
INDArray a,
float vl,
float vu,
int il,
int iu,
float abstol,
INDArray w,
INDArray z) |
int |
BlasWrapper.sygvd(int itype,
char jobz,
char uplo,
INDArray A,
INDArray B,
INDArray W) |
int |
BaseBlasWrapper.sygvd(int itype,
char jobz,
char uplo,
INDArray A,
INDArray B,
INDArray W) |
INDArray |
BlasWrapper.sysv(char uplo,
INDArray a,
int[] ipiv,
INDArray b) |
INDArray |
BaseBlasWrapper.sysv(char uplo,
INDArray a,
int[] ipiv,
INDArray b) |
INDArray[] |
NDArrayFactory.tear(INDArray tensor,
int... dimensions) |
static INDArray[] |
Nd4j.tear(INDArray tensor,
int... dimensions)
This method does the opposite to pile/vstack/hstack - it returns independent TAD copies along given dimensions
|
static INDArray |
Nd4j.tensorMmul(INDArray a,
INDArray b,
INDArray result,
int[][] axes)
Tensor matrix multiplication.
|
static INDArray |
Nd4j.tensorMmul(INDArray a,
INDArray b,
int[][] axes)
Tensor matrix multiplication.
|
static INDArray |
Nd4j.tile(INDArray tile,
int... repeat)
An alias for repmat
|
static byte[] |
Nd4j.toByteArray(INDArray arr)
Convert an ndarray to a byte array
|
INDArray |
NDArrayFactory.toFlattened(char order,
INDArray... matrices)
Flatten all of the ndarrays in to one long vector
|
static INDArray |
Nd4j.toFlattened(char order,
INDArray... matrices)
Create a long row vector of all of the given ndarrays/
|
INDArray |
BaseNDArrayFactory.toFlattened(char order,
INDArray... matrices) |
INDArray |
NDArrayFactory.toFlattened(INDArray... matrices)
Flatten all of the ndarrays in to one long vector
|
static INDArray |
Nd4j.toFlattened(INDArray... matrices)
Create a long row vector of all of the given ndarrays
|
INDArray |
BaseNDArrayFactory.toFlattened(INDArray... matrices) |
static byte[] |
Nd4j.toNpyByteArray(INDArray input)
Converts an
INDArray to a byte array |
static INDArray |
Nd4j.triu(INDArray m,
int k)
Upper triangle of an array.
|
static void |
NDValidation.validateBool(String opName,
INDArray v)
Validate that the operation is being applied on a boolean type INDArray
|
static void |
NDValidation.validateBool(String opName,
INDArray v1,
INDArray v2)
Validate that the operation is being applied on boolean INDArrays
|
static void |
NDValidation.validateBool(String opName,
String inputName,
INDArray v)
Validate that the operation is being applied on a boolean type INDArray
|
static void |
Broadcast.validateBroadcastDims(INDArray x,
INDArray y,
INDArray z,
int... dimensions)
Validate the broadcast dimensions for manual broadcast ops such as
BroadcastMulOp. |
static void |
NDValidation.validateFloatingPoint(String opName,
INDArray v)
Validate that the operation is being applied on an floating point type INDArray
|
static void |
NDValidation.validateFloatingPoint(String opName,
String inputName,
INDArray v)
Validate that the operation is being applied on a floating point type INDArray
|
static void |
NDValidation.validateInteger(String opName,
INDArray v)
Validate that the operation is being applied on an integer type INDArray
|
static void |
NDValidation.validateInteger(String opName,
String inputName,
INDArray v)
Validate that the operation is being applied on an integer type INDArray
|
static void |
NDValidation.validateNumerical(String opName,
INDArray v)
Validate that the operation is being applied on a numerical INDArray (not boolean or utf8).
|
static void |
NDValidation.validateNumerical(String opName,
INDArray[] v)
Validate that the operation is being applied on numerical INDArrays (not boolean or utf8).
|
static void |
NDValidation.validateNumerical(String opName,
INDArray v1,
INDArray v2)
Validate that the operation is being applied on numerical INDArrays (not boolean or utf8).
|
static void |
NDValidation.validateNumerical(String opName,
String inputName,
INDArray v)
Validate that the operation is being applied on a numerical INDArray (not boolean or utf8).
|
static void |
NDValidation.validateNumerical(String opName,
String inputName,
INDArray[] v)
Validate that the operation is being applied on numerical INDArrays (not boolean or utf8).
|
static void |
NDValidation.validateSameType(String opName,
boolean numericalOnly,
INDArray... vars)
Validate that the operation is being applied on array with the exact same datatypes (which may optionally be
restricted to numerical INDArrays only (not boolean or utf8))
|
static void |
Broadcast.validateShapesNoDimCase(INDArray x,
INDArray y,
INDArray z) |
static INDArray |
Nd4j.var(INDArray compute)
See
var(int...) with Integer.MAX_VALUE for full array reduction. |
static INDArray |
Nd4j.var(INDArray compute,
int dimension)
See
var(int...) with Integer.MAX_VALUE for full array reduction. |
INDArray |
NDArrayFactory.vstack(INDArray... arrs)
Concatenates two matrices vertically.
|
static INDArray |
Nd4j.vstack(INDArray... arrs)
Concatenates two matrices vertically.
|
INDArray |
BaseNDArrayFactory.vstack(INDArray... arrs)
Concatenates two matrices vertically.
|
static INDArray[] |
Nd4j.where(INDArray condition,
INDArray x,
INDArray y)
Similar to numpy.where operation.
|
static void |
Nd4j.write(INDArray arr,
DataOutputStream dataOutputStream)
Write an ndarray to the specified outputstream
|
static void |
Nd4j.write(OutputStream writer,
INDArray write)
Y
Write an ndarray to a writer
|
static void |
Nd4j.writeAsNumpy(INDArray arr,
File file)
|
static void |
Nd4j.writeAsNumpy(INDArray arr,
OutputStream writeTo)
Writes an array to an output stream
|
static void |
Nd4j.writeTxt(INDArray write,
String filePath)
Write NDArray to a text file
|
static void |
Nd4j.writeTxt(INDArray write,
String filePath,
int precision)
Deprecated.
Defaults to scientific notation with 18 digits after the decimal
Use
Nd4j.writeTxt(INDArray, String) |
static void |
Nd4j.writeTxt(INDArray write,
String filePath,
String split)
Deprecated.
custom col and higher dimension separators are no longer supported; uses ","
Use
Nd4j.writeTxt(INDArray, String) |
static void |
Nd4j.writeTxt(INDArray write,
String filePath,
String split,
int precision)
Deprecated.
Precision is no longer used. Split is no longer used.
Defaults to scientific notation with 18 digits after the decimal
Use
Nd4j.writeTxt(INDArray, String) |
static INDArray |
Nd4j.zerosLike(INDArray arr)
Empty like
|
| Modifier and Type | Method and Description |
|---|---|
static INDArray |
Nd4j.accumulate(INDArray target,
Collection<INDArray> arrays)
This method sums given arrays and stores them to a given target array
|
INDArray |
NDArrayFactory.average(Collection<INDArray> arrays)
This method averages input arrays, and returns averaged array
|
INDArray |
NDArrayFactory.average(INDArray target,
Collection<INDArray> arrays)
This method averages input arrays, and returns averaged array
|
static INDArray |
Nd4j.averageAndPropagate(Collection<INDArray> arrays)
This method averages input arrays, and returns averaged array.
|
static INDArray |
Nd4j.averageAndPropagate(INDArray target,
Collection<INDArray> arrays)
This method averages input arrays, and returns averaged array.
|
static INDArray |
Nd4j.create(List<INDArray> list,
int... shape)
Creates an array with the specified shape from a list of arrays.
|
INDArray |
NDArrayFactory.create(List<INDArray> list,
int[] shape)
Creates an ndarray with the specified shape
|
abstract INDArray |
BaseNDArrayFactory.create(List<INDArray> list,
int[] shape)
Creates an ndarray with the specified shape
|
INDArray |
NDArrayFactory.create(List<INDArray> list,
int[] shape,
char ordering) |
static INDArray |
Nd4j.create(List<INDArray> list,
long... shape)
|
INDArray |
NDArrayFactory.create(List<INDArray> list,
long[] shape) |
INDArray |
NDArrayFactory.create(List<INDArray> list,
long[] shape,
char ordering) |
static INDArray |
Nd4j.hstack(Collection<INDArray> arrs)
Concatenates two matrices horizontally.
|
static INDArray |
Nd4j.pile(Collection<INDArray> arrays)
This method stacks vertically examples with the same shape, increasing result dimensionality.
|
static void |
Nd4j.shuffle(Collection<INDArray> toShuffle,
int... dimension)
Symmetric in place shuffle of an ndarray
along a specified set of dimensions
|
void |
NDArrayFactory.shuffle(Collection<INDArray> array,
Random rnd,
int... dimension)
Symmetric in place shuffle of an ndarray
along a specified set of dimensions.
|
static void |
Nd4j.shuffle(Collection<INDArray> toShuffle,
Random rnd,
int... dimension)
Symmetric in place shuffle of an ndarray
along a specified set of dimensions
|
void |
NDArrayFactory.shuffle(List<INDArray> array,
Random rnd,
List<int[]> dimensions)
Symmetric in place shuffle of an ndarray
along a specified set of dimensions.
|
static void |
Nd4j.shuffle(List<INDArray> toShuffle,
Random rnd,
List<int[]> dimensions)
Symmetric in place shuffle of an ndarray
along a variable dimensions
|
INDArray |
NDArrayFactory.toFlattened(char order,
Collection<INDArray> matrices)
Returns a flattened ndarray with all elements in each ndarray
regardless of dimension.
|
static INDArray |
Nd4j.toFlattened(char order,
Collection<INDArray> matrices)
Create a long row vector of all of the given ndarrays
|
INDArray |
NDArrayFactory.toFlattened(Collection<INDArray> matrices)
/**
Returns a flattened ndarray with all of the elements in each ndarray
regardless of dimension
|
static INDArray |
Nd4j.toFlattened(Collection<INDArray> matrices)
Create a long row vector of all of the given ndarrays
|
INDArray |
BaseNDArrayFactory.toFlattened(Collection<INDArray> matrices)
Returns a vector with all of the elements in every nd array
equal to the sum of the lengths of the ndarrays
|
static INDArray |
Nd4j.vstack(Collection<INDArray> arrs)
Concatenates two matrices vertically.
|
| Modifier and Type | Method and Description |
|---|---|
INDArray |
NDMath.abs(INDArray x)
Elementwise absolute value operation: out = abs(x)
|
INDArray |
NDMath.acos(INDArray x)
Elementwise acos (arccosine, inverse cosine) operation: out = arccos(x)
|
INDArray |
NDMath.acosh(INDArray x)
Elementwise acosh (inverse hyperbolic cosine) function: out = acosh(x)
|
INDArray |
NDMath.amax(INDArray in,
int... dimensions)
Absolute max array reduction operation, optionally along specified dimensions: out = max(abs(x))
|
INDArray |
NDMath.amean(INDArray in,
int... dimensions)
Absolute mean array reduction operation, optionally along specified dimensions: out = mean(abs(x))
|
INDArray |
NDMath.amin(INDArray in,
int... dimensions)
Absolute min array reduction operation, optionally along specified dimensions: out = min(abs(x))
|
INDArray |
NDMath.and(INDArray x,
INDArray y)
Boolean AND operation: elementwise (x !
|
INDArray |
NDBitwise.and(INDArray x,
INDArray y)
Bitwise AND operation.
|
INDArray |
NDMath.asin(INDArray x)
Elementwise asin (arcsin, inverse sine) operation: out = arcsin(x)
|
INDArray |
NDMath.asinh(INDArray x)
Elementwise asinh (inverse hyperbolic sine) function: out = asinh(x)
|
INDArray |
NDMath.asum(INDArray in,
int... dimensions)
Absolute sum array reduction operation, optionally along specified dimensions: out = sum(abs(x))
|
INDArray |
NDMath.atan(INDArray x)
Elementwise atan (arctangent, inverse tangent) operation: out = arctangent(x)
|
INDArray |
NDMath.atan2(INDArray y,
INDArray x)
Elementwise atan (arctangent, inverse tangent) operation: out = atan2(x,y).
|
INDArray |
NDMath.atanh(INDArray x)
Elementwise atanh (inverse hyperbolic tangent) function: out = atanh(x)
|
INDArray |
NDNN.batchNorm(INDArray input,
INDArray mean,
INDArray variance,
INDArray gamma,
INDArray beta,
double epsilon,
int... axis)
Neural network batch normalization operation.
|
INDArray |
NDRandom.bernoulli(double p,
DataType datatype,
long... shape)
Generate a new random INDArray, where values are randomly sampled according to a Bernoulli distribution,
with the specified probability. |
INDArray |
NDNN.biasAdd(INDArray input,
INDArray bias,
boolean nchw)
Bias addition operation: a special case of addition, typically used with CNN 4D activations and a 1D bias vector
|
INDArray |
NDRandom.binomial(int nTrials,
double p,
DataType datatype,
long... shape)
Generate a new random INDArray, where values are randomly sampled according to a Binomial distribution,
with the specified number of trials and probability. |
INDArray |
NDBitwise.bitRotl(INDArray x,
INDArray shift)
Roll integer bits to the left, i.e. var << 4 | var >> (32 - 4)
|
INDArray |
NDBitwise.bitRotr(INDArray x,
INDArray shift)
Roll integer bits to the right, i.e. var >> 4 | var << (32 - 4)
|
INDArray |
NDBitwise.bitsHammingDistance(INDArray x,
INDArray y)
Bitwise Hamming distance reduction over all elements of both input arrays.
|
INDArray |
NDBitwise.bitShift(INDArray x,
INDArray shift)
Shift integer bits to the left, i.e. var << 4
|
INDArray |
NDBitwise.bitShiftRight(INDArray x,
INDArray shift)
Shift integer bits to the right, i.e. var >> 4
|
INDArray |
NDMath.ceil(INDArray x)
Element-wise ceiling function: out = ceil(x).
|
INDArray |
NDMath.clipByNorm(INDArray x,
double clipValue,
int... dimensions)
Clipping by L2 norm, optionally along dimension(s)
if l2Norm(x,dimension) < clipValue, then input is returned unmodifed Otherwise, out[i] = in[i] * clipValue / l2Norm(in, dimensions) where each value is clipped according to the corresponding l2Norm along the specified dimensions |
INDArray |
NDMath.clipByValue(INDArray x,
double clipValueMin,
double clipValueMax)
Element-wise clipping function:
out[i] = in[i] if in[i] >= clipValueMin and in[i] <= clipValueMax out[i] = clipValueMin if in[i] < clipValueMin out[i] = clipValueMax if in[i] > clipValueMax |
INDArray |
NDMath.confusionMatrix(INDArray labels,
INDArray pred,
DataType dataType)
Compute the 2d confusion matrix of size [numClasses, numClasses] from a pair of labels and predictions, both of
which are represented as integer values. |
INDArray |
NDMath.confusionMatrix(INDArray labels,
INDArray pred,
INDArray weights)
Compute the 2d confusion matrix of size [numClasses, numClasses] from a pair of labels and predictions, both of
which are represented as integer values. |
INDArray |
NDMath.confusionMatrix(INDArray labels,
INDArray pred,
INDArray weights,
int numClasses)
Compute the 2d confusion matrix of size [numClasses, numClasses] from a pair of labels and predictions, both of
which are represented as integer values. |
INDArray |
NDMath.confusionMatrix(INDArray labels,
INDArray pred,
int numClasses)
Compute the 2d confusion matrix of size [numClasses, numClasses] from a pair of labels and predictions, both of
which are represented as integer values. |
INDArray |
NDMath.cos(INDArray x)
Elementwise cosine operation: out = cos(x)
|
INDArray |
NDMath.cosh(INDArray x)
Elementwise cosh (hyperbolic cosine) operation: out = cosh(x)
|
INDArray |
NDMath.cosineDistance(INDArray x,
INDArray y,
int... dimensions)
Cosine distance reduction operation.
|
INDArray |
NDMath.cosineSimilarity(INDArray x,
INDArray y,
int... dimensions)
Cosine similarity pairwise reduction operation.
|
INDArray |
NDMath.countNonZero(INDArray in,
int... dimensions)
Count non zero array reduction operation, optionally along specified dimensions: out = count(x !
|
INDArray |
NDMath.countZero(INDArray in,
int... dimensions)
Count zero array reduction operation, optionally along specified dimensions: out = count(x == 0)
|
INDArray |
NDMath.cross(INDArray a,
INDArray b)
Returns the pair-wise cross product of equal size arrays a and b: a x b = ||a||x||b|| sin(theta).
|
INDArray |
NDMath.cube(INDArray x)
Element-wise cube function: out = x^3
|
INDArray |
NDMath.diag(INDArray x)
Returns an output variable with diagonal values equal to the specified values; off-diagonal values will be set to 0
For example, if input = [1,2,3], then output is given by: [ 1, 0, 0] [ 0, 2, 0] [ 0, 0, 3] Higher input ranks are also supported: if input has shape [a,... |
INDArray |
NDMath.diagPart(INDArray x)
Extract the diagonal part from the input array.
|
INDArray |
NDNN.dotProductAttention(INDArray queries,
INDArray keys,
INDArray values,
INDArray mask,
boolean scaled)
This operation performs dot product attention on the given timeseries input with the given queries
out = sum(similarity(k_i, q) * v_i) similarity(k, q) = softmax(k * q) where x * q is the dot product of x and q Optionally with normalization step: similarity(k, q) = softmax(k * q / sqrt(size(q)) See also "Attention is all you need" (https://arxiv.org/abs/1706.03762, p. 4, eq. 1) Note: This supports multiple queries at once, if only one query is available the queries vector still has to be 3D but can have queryCount = 1 Note: keys and values usually is the same array. |
INDArray |
NDNN.dropout(INDArray input,
double inputRetainProbability)
Dropout operation
|
INDArray |
NDNN.elu(INDArray x)
Element-wise exponential linear unit (ELU) function:
out = x if x > 0 out = a * (exp(x) - 1) if x <= 0 with constant a = 1.0 See: https://arxiv.org/abs/1511.07289 |
INDArray |
NDMath.entropy(INDArray in,
int... dimensions)
Entropy reduction: -sum(x * log(x))
|
INDArray |
NDMath.erf(INDArray x)
Element-wise Gaussian error function - out = erf(in)
|
INDArray |
NDMath.erfc(INDArray x)
Element-wise complementary Gaussian error function - out = erfc(in) = 1 - erf(in)
|
INDArray |
NDMath.euclideanDistance(INDArray x,
INDArray y,
int... dimensions)
Euclidean distance (l2 norm, l2 distance) reduction operation.
|
INDArray |
NDMath.exp(INDArray x)
Elementwise exponent function: out = exp(x) = 2.71828...
|
INDArray |
NDMath.expm1(INDArray x)
Elementwise 1.0 - exponent function: out = 1.0 - exp(x) = 1.0 - 2.71828...
|
INDArray[] |
NDRandom.exponential(double lambda,
DataType datatype,
long... shape)
Generate a new random INDArray, where values are randomly sampled according to a exponential distribution:
P(x) = lambda * exp(-lambda * x) Inputs must satisfy the following constraints: Must be positive: lambda > 0 |
INDArray |
NDMath.eye(INDArray rows)
As per eye(String, int) but with the number of rows specified as a scalar INDArray
|
INDArray |
NDMath.eye(INDArray rows,
INDArray cols)
As per eye(int, int) bit with the number of rows/columns specified as scalar INDArrays
|
INDArray |
NDMath.eye(int rows)
Generate an identity matrix with the specified number of rows and columns.
|
INDArray |
NDMath.eye(int rows,
int cols)
As per eye(String, int, int, DataType) but with the default datatype, Eye.DEFAULT_DTYPE
|
INDArray |
NDMath.eye(int rows,
int cols,
DataType dataType)
Generate an identity matrix with the specified number of rows and columns
Example: INDArray eye = eye(3,2)<br>
eye:<br>
[ 1, 0]<br>
[ 0, 1]<br>
[ 0, 0] |
INDArray |
NDMath.firstIndex(INDArray in,
Condition condition,
boolean keepDims,
int... dimensions)
First index reduction operation.
|
INDArray |
NDMath.firstIndex(INDArray in,
Condition condition,
int... dimensions)
First index reduction operation.
|
INDArray |
NDMath.floor(INDArray x)
Element-wise floor function: out = floor(x).
|
INDArray |
NDNN.gelu(INDArray x)
GELU activation function - Gaussian Error Linear Units
For more details, see Gaussian Error Linear Units (GELUs) - https://arxiv.org/abs/1606.08415 This method uses the sigmoid approximation |
INDArray |
NDMath.hammingDistance(INDArray x,
INDArray y,
int... dimensions)
Hamming distance reduction operation.
|
INDArray |
NDNN.hardSigmoid(INDArray x)
Element-wise hard sigmoid function:
out[i] = 0 if in[i] <= -2.5 out[1] = 0.2*in[i]+0.5 if -2.5 < in[i] < 2.5 out[i] = 1 if in[i] >= 2.5 |
INDArray |
NDNN.hardTanh(INDArray x)
Element-wise hard tanh function:
out[i] = -1 if in[i] <= -1 out[1] = in[i] if -1 < in[i] < 1 out[i] = 1 if in[i] >= 1 |
INDArray |
NDNN.hardTanhDerivative(INDArray x)
Derivative (dOut/dIn) of the element-wise hard Tanh function - hardTanh(INDArray)
|
INDArray |
NDMath.iamax(INDArray in,
boolean keepDims,
int... dimensions)
Index of the max absolute value: argmax(abs(in))
see argmax(String, INDArray, boolean, int...) |
INDArray |
NDMath.iamax(INDArray in,
int... dimensions)
Index of the max absolute value: argmax(abs(in))
see argmax(String, INDArray, boolean, int...) |
INDArray |
NDMath.iamin(INDArray in,
boolean keepDims,
int... dimensions)
Index of the min absolute value: argmin(abs(in))
see argmin(String, INDArray, boolean, int...) |
INDArray |
NDMath.iamin(INDArray in,
int... dimensions)
Index of the min absolute value: argmin(abs(in))
see argmin(String, INDArray, boolean, int...) |
INDArray |
NDMath.isFinite(INDArray x)
Is finite operation: elementwise isFinite(x)
Returns an array with the same shape/size as the input, with values 1 where condition is satisfied, or value 0 otherwise |
INDArray |
NDMath.isInfinite(INDArray x)
Is infinite operation: elementwise isInfinite(x)
Returns an array with the same shape/size as the input, with values 1 where condition is satisfied, or value 0 otherwise |
INDArray |
NDMath.isMax(INDArray x)
Is maximum operation: elementwise x == max(x)
Returns an array with the same shape/size as the input, with values 1 where condition is satisfied, or value 0 otherwise |
INDArray |
NDMath.isNaN(INDArray x)
Is Not a Number operation: elementwise isNaN(x)
Returns an array with the same shape/size as the input, with values 1 where condition is satisfied, or value 0 otherwise |
INDArray |
NDMath.isNonDecreasing(INDArray x)
Is the array non decreasing?
|
INDArray |
NDMath.isStrictlyIncreasing(INDArray x)
Is the array strictly increasing?
|
INDArray |
NDMath.jaccardDistance(INDArray x,
INDArray y,
int... dimensions)
Jaccard similarity reduction operation.
|
INDArray |
NDMath.lastIndex(INDArray in,
Condition condition,
boolean keepDims,
int... dimensions)
Last index reduction operation.
|
INDArray |
NDMath.lastIndex(INDArray in,
Condition condition,
int... dimensions)
Last index reduction operation.
|
INDArray |
NDNN.layerNorm(INDArray input,
INDArray gain,
boolean channelsFirst,
int... dimensions)
Apply Layer Normalization
y = gain * standardize(x) + bias |
INDArray |
NDNN.layerNorm(INDArray input,
INDArray gain,
INDArray bias,
boolean channelsFirst,
int... dimensions)
Apply Layer Normalization
y = gain * standardize(x) + bias |
INDArray |
NDNN.leakyRelu(INDArray x,
INDArray alpha)
Element-wise leaky ReLU function:
out = x if x >= 0.0 out = alpha * x if x < cutoff Alpha value is most commonly set to 0.01 |
INDArray |
NDNN.leakyReluDerivative(INDArray x,
INDArray alpha)
Leaky ReLU derivative: dOut/dIn given input.
|
INDArray |
NDBitwise.leftShift(INDArray x,
INDArray y)
Bitwise left shift operation.
|
INDArray |
NDBitwise.leftShiftCyclic(INDArray x,
INDArray y)
Bitwise left cyclical shift operation.
|
INDArray |
NDNN.linear(INDArray input,
INDArray weights,
INDArray bias)
Linear layer operation: out = mmul(in,w) + bias
Note that bias array is optional |
INDArray |
NDMath.log(INDArray x)
Element-wise logarithm function (base e - natural logarithm): out = log(x)
|
INDArray |
NDMath.log(INDArray x,
INDArray base)
Element-wise logarithm function (with specified base): out = log_{base}(x)
|
INDArray |
NDMath.log1p(INDArray x)
Elementwise natural logarithm function: out = log_e (1 + x)
|
INDArray |
NDMath.logEntropy(INDArray in,
int... dimensions)
Log entropy reduction: log(-sum(x * log(x)))
|
INDArray |
NDRandom.logNormal(double mean,
double stddev,
DataType datatype,
long... shape)
Generate a new random INDArray, where values are randomly sampled according to a Log Normal distribution,
i.e., log(x) ~ N(mean, stdev) |
INDArray |
NDNN.logSigmoid(INDArray x)
Element-wise sigmoid function: out[i] = log(sigmoid(in[i]))
|
INDArray |
NDNN.logSoftmax(INDArray x)
Log softmax activation
|
INDArray |
NDNN.logSoftmax(INDArray x,
int dimension)
Log softmax activation
|
INDArray |
NDMath.logSumExp(INDArray input,
int... dimensions)
Log-sum-exp reduction (optionally along dimension).
|
INDArray |
NDMath.manhattanDistance(INDArray x,
INDArray y,
int... dimensions)
Manhattan distance (l1 norm, l1 distance) reduction operation.
|
INDArray |
NDMath.matrixDeterminant(INDArray in)
Matrix determinant op.
|
INDArray |
NDMath.matrixInverse(INDArray in)
Matrix inverse op.
|
INDArray |
NDMath.mergeAdd(INDArray[] inputs)
Merge add function: merges an arbitrary number of equal shaped arrays using element-wise addition:
out = sum_i in[i] |
INDArray |
NDMath.mergeAvg(INDArray[] inputs)
Merge average function: merges an arbitrary number of equal shaped arrays using element-wise mean operation:
out = mean_i in[i] |
INDArray |
NDMath.mergeMax(INDArray[] inputs)
Merge max function: merges an arbitrary number of equal shaped arrays using element-wise maximum operation:
out = max_i in[i] |
INDArray |
NDMath.moments(INDArray input,
int... axes)
Calculate the mean and (population) variance for the input variable, for the specified axis
|
INDArray |
NDNN.multiHeadDotProductAttention(INDArray queries,
INDArray keys,
INDArray values,
INDArray Wq,
INDArray Wk,
INDArray Wv,
INDArray Wo,
INDArray mask,
boolean scaled)
This performs multi-headed dot product attention on the given timeseries input
out = concat(head_1, head_2, ..., head_n) * Wo head_i = dot_product_attention(Wq_i*q, Wk_i*k, Wv_i*v) Optionally with normalization when calculating the attention for each head. |
INDArray |
NDMath.neg(INDArray x)
Elementwise negative operation: out = -x
|
INDArray |
NDRandom.normal(double mean,
double stddev,
DataType datatype,
long... shape)
Generate a new random INDArray, where values are randomly sampled according to a Gaussian (normal) distribution,
N(mean, stdev) |
INDArray |
NDMath.normalizeMoments(INDArray counts,
INDArray means,
INDArray variances,
double shift)
Calculate the mean and variance from the sufficient statistics
|
INDArray |
NDRandom.normalTruncated(double mean,
double stddev,
DataType datatype,
long... shape)
Generate a new random INDArray, where values are randomly sampled according to a Gaussian (normal) distribution,
N(mean, stdev). |
INDArray |
NDMath.or(INDArray x,
INDArray y)
Boolean OR operation: elementwise (x !
|
INDArray |
NDBitwise.or(INDArray x,
INDArray y)
Bitwise OR operation.
|
INDArray |
NDMath.pow(INDArray x,
double value)
Element-wise power function: out = x^value
|
INDArray |
NDMath.pow(INDArray x,
INDArray y)
Element-wise (broadcastable) power function: out = x[i]^y[i]
|
INDArray |
NDNN.prelu(INDArray input,
INDArray alpha,
int... sharedAxes)
PReLU (Parameterized Rectified Linear Unit) operation.
|
INDArray |
NDMath.reciprocal(INDArray x)
Element-wise reciprocal (inverse) function: out[i] = 1 / in[i]
|
INDArray |
NDNN.relu(INDArray x,
double cutoff)
Element-wise rectified linear function with specified cutoff:
out[i] = in[i] if in[i] >= cutoff out[i] = 0 otherwise |
INDArray |
NDNN.relu6(INDArray x,
double cutoff)
Element-wise "rectified linear 6" function with specified cutoff:
out[i] = min(max(in, cutoff), 6) |
INDArray |
NDNN.reluLayer(INDArray input,
INDArray weights,
INDArray bias)
ReLU (Rectified Linear Unit) layer operation: out = relu(mmul(in,w) + bias)
Note that bias array is optional |
INDArray |
NDBitwise.rightShift(INDArray x,
INDArray y)
Bitwise right shift operation.
|
INDArray |
NDBitwise.rightShiftCyclic(INDArray x,
INDArray y)
Bitwise right cyclical shift operation.
|
INDArray |
NDMath.round(INDArray x)
Element-wise round function: out = round(x).
|
INDArray |
NDMath.rsqrt(INDArray x)
Element-wise reciprocal (inverse) of square root: out = 1.0 / sqrt(x)
|
INDArray |
NDNN.selu(INDArray x)
Element-wise SeLU function - Scaled exponential Lineal Unit: see Self-Normalizing Neural Networks
out[i] = scale * alpha * (exp(in[i])-1) if in[i]>0, or 0 if in[i] <= 0 Uses default scale and alpha values. |
INDArray |
NDMath.setDiag(INDArray in,
INDArray diag)
Set the diagonal value to the specified values
If input is [ a, b, c] [ d, e, f] [ g, h, i] and diag = [ 1, 2, 3] then output is [ 1, b, c] [ d, 2, f] [ g, h, 3] |
INDArray |
NDMath.shannonEntropy(INDArray in,
int... dimensions)
Shannon Entropy reduction: -sum(x * log2(x))
|
INDArray |
NDNN.sigmoid(INDArray x)
Element-wise sigmoid function: out[i] = 1.0/(1+exp(-in[i]))
|
INDArray |
NDNN.sigmoidDerivative(INDArray x,
INDArray wrt)
Element-wise sigmoid function derivative: dL/dIn given input and dL/dOut
|
INDArray |
NDMath.sign(INDArray x)
Element-wise sign (signum) function:
out = -1 if in < 0 out = 0 if in = 0 out = 1 if in > 0 |
INDArray |
NDMath.sin(INDArray x)
Elementwise sine operation: out = sin(x)
|
INDArray |
NDMath.sinh(INDArray x)
Elementwise sinh (hyperbolic sine) operation: out = sinh(x)
|
INDArray |
NDNN.softmax(INDArray x,
int dimension)
Softmax activation, along the specified dimension
|
INDArray |
NDNN.softmaxDerivative(INDArray x,
INDArray wrt,
int dimension)
Softmax derivative function
|
INDArray |
NDNN.softplus(INDArray x)
Element-wise softplus function: out = log(exp(x) + 1)
|
INDArray |
NDNN.softsign(INDArray x)
Element-wise softsign function: out = x / (abs(x) + 1)
|
INDArray |
NDNN.softsignDerivative(INDArray x)
Element-wise derivative (dOut/dIn) of the softsign function softsign(INDArray)
|
INDArray |
NDMath.sqrt(INDArray x)
Element-wise square root function: out = sqrt(x)
|
INDArray |
NDMath.square(INDArray x)
Element-wise square function: out = x^2
|
INDArray |
NDMath.standardize(INDArray x,
int... dimensions)
Standardize input variable along given axis
out = (x - mean) / stdev with mean and stdev being calculated along the given dimension. |
INDArray |
NDMath.step(INDArray x,
double value)
Elementwise step function:
out(x) = 1 if x >= cutoff out(x) = 0 otherwise |
INDArray |
NDNN.swish(INDArray x)
Element-wise "swish" function: out = x * sigmoid(b*x) with b=1.0
See: https://arxiv.org/abs/1710.05941 |
INDArray |
NDMath.tan(INDArray x)
Elementwise tangent operation: out = tan(x)
|
INDArray |
NDMath.tanh(INDArray x)
Elementwise tanh (hyperbolic tangent) operation: out = tanh(x)
|
INDArray |
NDMath.trace(INDArray in)
Matrix trace operation
For rank 2 matrices, the output is a scalar vith the trace - i.e., sum of the main diagonal. |
INDArray |
NDRandom.uniform(double min,
double max,
DataType datatype,
long... shape)
Generate a new random INDArray, where values are randomly sampled according to a uniform distribution,
U(min,max) |
INDArray |
NDMath.xor(INDArray x,
INDArray y)
Boolean XOR (exclusive OR) operation: elementwise (x !
|
INDArray |
NDBitwise.xor(INDArray x,
INDArray y)
Bitwise XOR operation (exclusive OR).
|
INDArray |
NDMath.zeroFraction(INDArray input)
Full array zero fraction array reduction operation, optionally along specified dimensions: out = (count(x == 0) / length(x))
|
| Modifier and Type | Method and Description |
|---|---|
INDArray |
NDMath.abs(INDArray x)
Elementwise absolute value operation: out = abs(x)
|
INDArray |
NDMath.acos(INDArray x)
Elementwise acos (arccosine, inverse cosine) operation: out = arccos(x)
|
INDArray |
NDMath.acosh(INDArray x)
Elementwise acosh (inverse hyperbolic cosine) function: out = acosh(x)
|
INDArray |
NDMath.amax(INDArray in,
int... dimensions)
Absolute max array reduction operation, optionally along specified dimensions: out = max(abs(x))
|
INDArray |
NDMath.amean(INDArray in,
int... dimensions)
Absolute mean array reduction operation, optionally along specified dimensions: out = mean(abs(x))
|
INDArray |
NDMath.amin(INDArray in,
int... dimensions)
Absolute min array reduction operation, optionally along specified dimensions: out = min(abs(x))
|
INDArray |
NDMath.and(INDArray x,
INDArray y)
Boolean AND operation: elementwise (x !
|
INDArray |
NDBitwise.and(INDArray x,
INDArray y)
Bitwise AND operation.
|
INDArray |
NDMath.asin(INDArray x)
Elementwise asin (arcsin, inverse sine) operation: out = arcsin(x)
|
INDArray |
NDMath.asinh(INDArray x)
Elementwise asinh (inverse hyperbolic sine) function: out = asinh(x)
|
INDArray |
NDMath.asum(INDArray in,
int... dimensions)
Absolute sum array reduction operation, optionally along specified dimensions: out = sum(abs(x))
|
INDArray |
NDMath.atan(INDArray x)
Elementwise atan (arctangent, inverse tangent) operation: out = arctangent(x)
|
INDArray |
NDMath.atan2(INDArray y,
INDArray x)
Elementwise atan (arctangent, inverse tangent) operation: out = atan2(x,y).
|
INDArray |
NDMath.atanh(INDArray x)
Elementwise atanh (inverse hyperbolic tangent) function: out = atanh(x)
|
INDArray |
NDNN.batchNorm(INDArray input,
INDArray mean,
INDArray variance,
INDArray gamma,
INDArray beta,
double epsilon,
int... axis)
Neural network batch normalization operation.
|
INDArray |
NDNN.biasAdd(INDArray input,
INDArray bias,
boolean nchw)
Bias addition operation: a special case of addition, typically used with CNN 4D activations and a 1D bias vector
|
INDArray |
NDBitwise.bitRotl(INDArray x,
INDArray shift)
Roll integer bits to the left, i.e. var << 4 | var >> (32 - 4)
|
INDArray |
NDBitwise.bitRotr(INDArray x,
INDArray shift)
Roll integer bits to the right, i.e. var >> 4 | var << (32 - 4)
|
INDArray |
NDBitwise.bitsHammingDistance(INDArray x,
INDArray y)
Bitwise Hamming distance reduction over all elements of both input arrays.
|
INDArray |
NDBitwise.bitShift(INDArray x,
INDArray shift)
Shift integer bits to the left, i.e. var << 4
|
INDArray |
NDBitwise.bitShiftRight(INDArray x,
INDArray shift)
Shift integer bits to the right, i.e. var >> 4
|
INDArray |
NDMath.ceil(INDArray x)
Element-wise ceiling function: out = ceil(x).
|
INDArray |
NDMath.clipByNorm(INDArray x,
double clipValue,
int... dimensions)
Clipping by L2 norm, optionally along dimension(s)
if l2Norm(x,dimension) < clipValue, then input is returned unmodifed Otherwise, out[i] = in[i] * clipValue / l2Norm(in, dimensions) where each value is clipped according to the corresponding l2Norm along the specified dimensions |
INDArray |
NDMath.clipByValue(INDArray x,
double clipValueMin,
double clipValueMax)
Element-wise clipping function:
out[i] = in[i] if in[i] >= clipValueMin and in[i] <= clipValueMax out[i] = clipValueMin if in[i] < clipValueMin out[i] = clipValueMax if in[i] > clipValueMax |
INDArray |
NDMath.confusionMatrix(INDArray labels,
INDArray pred,
DataType dataType)
Compute the 2d confusion matrix of size [numClasses, numClasses] from a pair of labels and predictions, both of
which are represented as integer values. |
INDArray |
NDMath.confusionMatrix(INDArray labels,
INDArray pred,
INDArray weights)
Compute the 2d confusion matrix of size [numClasses, numClasses] from a pair of labels and predictions, both of
which are represented as integer values. |
INDArray |
NDMath.confusionMatrix(INDArray labels,
INDArray pred,
INDArray weights,
int numClasses)
Compute the 2d confusion matrix of size [numClasses, numClasses] from a pair of labels and predictions, both of
which are represented as integer values. |
INDArray |
NDMath.confusionMatrix(INDArray labels,
INDArray pred,
int numClasses)
Compute the 2d confusion matrix of size [numClasses, numClasses] from a pair of labels and predictions, both of
which are represented as integer values. |
INDArray |
NDMath.cos(INDArray x)
Elementwise cosine operation: out = cos(x)
|
INDArray |
NDMath.cosh(INDArray x)
Elementwise cosh (hyperbolic cosine) operation: out = cosh(x)
|
INDArray |
NDMath.cosineDistance(INDArray x,
INDArray y,
int... dimensions)
Cosine distance reduction operation.
|
INDArray |
NDMath.cosineSimilarity(INDArray x,
INDArray y,
int... dimensions)
Cosine similarity pairwise reduction operation.
|
INDArray |
NDMath.countNonZero(INDArray in,
int... dimensions)
Count non zero array reduction operation, optionally along specified dimensions: out = count(x !
|
INDArray |
NDMath.countZero(INDArray in,
int... dimensions)
Count zero array reduction operation, optionally along specified dimensions: out = count(x == 0)
|
INDArray |
NDMath.cross(INDArray a,
INDArray b)
Returns the pair-wise cross product of equal size arrays a and b: a x b = ||a||x||b|| sin(theta).
|
INDArray |
NDMath.cube(INDArray x)
Element-wise cube function: out = x^3
|
INDArray |
NDMath.diag(INDArray x)
Returns an output variable with diagonal values equal to the specified values; off-diagonal values will be set to 0
For example, if input = [1,2,3], then output is given by: [ 1, 0, 0] [ 0, 2, 0] [ 0, 0, 3] Higher input ranks are also supported: if input has shape [a,... |
INDArray |
NDMath.diagPart(INDArray x)
Extract the diagonal part from the input array.
|
INDArray |
NDNN.dotProductAttention(INDArray queries,
INDArray keys,
INDArray values,
INDArray mask,
boolean scaled)
This operation performs dot product attention on the given timeseries input with the given queries
out = sum(similarity(k_i, q) * v_i) similarity(k, q) = softmax(k * q) where x * q is the dot product of x and q Optionally with normalization step: similarity(k, q) = softmax(k * q / sqrt(size(q)) See also "Attention is all you need" (https://arxiv.org/abs/1706.03762, p. 4, eq. 1) Note: This supports multiple queries at once, if only one query is available the queries vector still has to be 3D but can have queryCount = 1 Note: keys and values usually is the same array. |
INDArray |
NDNN.dropout(INDArray input,
double inputRetainProbability)
Dropout operation
|
INDArray |
NDNN.elu(INDArray x)
Element-wise exponential linear unit (ELU) function:
out = x if x > 0 out = a * (exp(x) - 1) if x <= 0 with constant a = 1.0 See: https://arxiv.org/abs/1511.07289 |
INDArray |
NDMath.entropy(INDArray in,
int... dimensions)
Entropy reduction: -sum(x * log(x))
|
INDArray |
NDMath.erf(INDArray x)
Element-wise Gaussian error function - out = erf(in)
|
INDArray |
NDMath.erfc(INDArray x)
Element-wise complementary Gaussian error function - out = erfc(in) = 1 - erf(in)
|
INDArray |
NDMath.euclideanDistance(INDArray x,
INDArray y,
int... dimensions)
Euclidean distance (l2 norm, l2 distance) reduction operation.
|
INDArray |
NDMath.exp(INDArray x)
Elementwise exponent function: out = exp(x) = 2.71828...
|
INDArray |
NDMath.expm1(INDArray x)
Elementwise 1.0 - exponent function: out = 1.0 - exp(x) = 1.0 - 2.71828...
|
INDArray |
NDMath.eye(INDArray rows)
As per eye(String, int) but with the number of rows specified as a scalar INDArray
|
INDArray |
NDMath.eye(INDArray rows,
INDArray cols)
As per eye(int, int) bit with the number of rows/columns specified as scalar INDArrays
|
INDArray |
NDMath.firstIndex(INDArray in,
Condition condition,
boolean keepDims,
int... dimensions)
First index reduction operation.
|
INDArray |
NDMath.firstIndex(INDArray in,
Condition condition,
int... dimensions)
First index reduction operation.
|
INDArray |
NDMath.floor(INDArray x)
Element-wise floor function: out = floor(x).
|
INDArray |
NDNN.gelu(INDArray x)
GELU activation function - Gaussian Error Linear Units
For more details, see Gaussian Error Linear Units (GELUs) - https://arxiv.org/abs/1606.08415 This method uses the sigmoid approximation |
INDArray |
NDMath.hammingDistance(INDArray x,
INDArray y,
int... dimensions)
Hamming distance reduction operation.
|
INDArray |
NDNN.hardSigmoid(INDArray x)
Element-wise hard sigmoid function:
out[i] = 0 if in[i] <= -2.5 out[1] = 0.2*in[i]+0.5 if -2.5 < in[i] < 2.5 out[i] = 1 if in[i] >= 2.5 |
INDArray |
NDNN.hardTanh(INDArray x)
Element-wise hard tanh function:
out[i] = -1 if in[i] <= -1 out[1] = in[i] if -1 < in[i] < 1 out[i] = 1 if in[i] >= 1 |
INDArray |
NDNN.hardTanhDerivative(INDArray x)
Derivative (dOut/dIn) of the element-wise hard Tanh function - hardTanh(INDArray)
|
INDArray |
NDMath.iamax(INDArray in,
boolean keepDims,
int... dimensions)
Index of the max absolute value: argmax(abs(in))
see argmax(String, INDArray, boolean, int...) |
INDArray |
NDMath.iamax(INDArray in,
int... dimensions)
Index of the max absolute value: argmax(abs(in))
see argmax(String, INDArray, boolean, int...) |
INDArray |
NDMath.iamin(INDArray in,
boolean keepDims,
int... dimensions)
Index of the min absolute value: argmin(abs(in))
see argmin(String, INDArray, boolean, int...) |
INDArray |
NDMath.iamin(INDArray in,
int... dimensions)
Index of the min absolute value: argmin(abs(in))
see argmin(String, INDArray, boolean, int...) |
INDArray |
NDMath.isFinite(INDArray x)
Is finite operation: elementwise isFinite(x)
Returns an array with the same shape/size as the input, with values 1 where condition is satisfied, or value 0 otherwise |
INDArray |
NDMath.isInfinite(INDArray x)
Is infinite operation: elementwise isInfinite(x)
Returns an array with the same shape/size as the input, with values 1 where condition is satisfied, or value 0 otherwise |
INDArray |
NDMath.isMax(INDArray x)
Is maximum operation: elementwise x == max(x)
Returns an array with the same shape/size as the input, with values 1 where condition is satisfied, or value 0 otherwise |
INDArray |
NDMath.isNaN(INDArray x)
Is Not a Number operation: elementwise isNaN(x)
Returns an array with the same shape/size as the input, with values 1 where condition is satisfied, or value 0 otherwise |
INDArray |
NDMath.isNonDecreasing(INDArray x)
Is the array non decreasing?
|
INDArray |
NDMath.isStrictlyIncreasing(INDArray x)
Is the array strictly increasing?
|
INDArray |
NDMath.jaccardDistance(INDArray x,
INDArray y,
int... dimensions)
Jaccard similarity reduction operation.
|
INDArray |
NDMath.lastIndex(INDArray in,
Condition condition,
boolean keepDims,
int... dimensions)
Last index reduction operation.
|
INDArray |
NDMath.lastIndex(INDArray in,
Condition condition,
int... dimensions)
Last index reduction operation.
|
INDArray |
NDNN.layerNorm(INDArray input,
INDArray gain,
boolean channelsFirst,
int... dimensions)
Apply Layer Normalization
y = gain * standardize(x) + bias |
INDArray |
NDNN.layerNorm(INDArray input,
INDArray gain,
INDArray bias,
boolean channelsFirst,
int... dimensions)
Apply Layer Normalization
y = gain * standardize(x) + bias |
INDArray |
NDNN.leakyRelu(INDArray x,
INDArray alpha)
Element-wise leaky ReLU function:
out = x if x >= 0.0 out = alpha * x if x < cutoff Alpha value is most commonly set to 0.01 |
INDArray |
NDNN.leakyReluDerivative(INDArray x,
INDArray alpha)
Leaky ReLU derivative: dOut/dIn given input.
|
INDArray |
NDBitwise.leftShift(INDArray x,
INDArray y)
Bitwise left shift operation.
|
INDArray |
NDBitwise.leftShiftCyclic(INDArray x,
INDArray y)
Bitwise left cyclical shift operation.
|
INDArray |
NDNN.linear(INDArray input,
INDArray weights,
INDArray bias)
Linear layer operation: out = mmul(in,w) + bias
Note that bias array is optional |
INDArray |
NDMath.log(INDArray x)
Element-wise logarithm function (base e - natural logarithm): out = log(x)
|
INDArray |
NDMath.log(INDArray x,
INDArray base)
Element-wise logarithm function (with specified base): out = log_{base}(x)
|
INDArray |
NDMath.log1p(INDArray x)
Elementwise natural logarithm function: out = log_e (1 + x)
|
INDArray |
NDMath.logEntropy(INDArray in,
int... dimensions)
Log entropy reduction: log(-sum(x * log(x)))
|
INDArray |
NDNN.logSigmoid(INDArray x)
Element-wise sigmoid function: out[i] = log(sigmoid(in[i]))
|
INDArray |
NDNN.logSoftmax(INDArray x)
Log softmax activation
|
INDArray |
NDNN.logSoftmax(INDArray x,
int dimension)
Log softmax activation
|
INDArray |
NDMath.logSumExp(INDArray input,
int... dimensions)
Log-sum-exp reduction (optionally along dimension).
|
INDArray |
NDMath.manhattanDistance(INDArray x,
INDArray y,
int... dimensions)
Manhattan distance (l1 norm, l1 distance) reduction operation.
|
INDArray |
NDMath.matrixDeterminant(INDArray in)
Matrix determinant op.
|
INDArray |
NDMath.matrixInverse(INDArray in)
Matrix inverse op.
|
INDArray |
NDMath.mergeAdd(INDArray[] inputs)
Merge add function: merges an arbitrary number of equal shaped arrays using element-wise addition:
out = sum_i in[i] |
INDArray |
NDMath.mergeAvg(INDArray[] inputs)
Merge average function: merges an arbitrary number of equal shaped arrays using element-wise mean operation:
out = mean_i in[i] |
INDArray |
NDMath.mergeMax(INDArray[] inputs)
Merge max function: merges an arbitrary number of equal shaped arrays using element-wise maximum operation:
out = max_i in[i] |
INDArray |
NDMath.moments(INDArray input,
int... axes)
Calculate the mean and (population) variance for the input variable, for the specified axis
|
INDArray |
NDNN.multiHeadDotProductAttention(INDArray queries,
INDArray keys,
INDArray values,
INDArray Wq,
INDArray Wk,
INDArray Wv,
INDArray Wo,
INDArray mask,
boolean scaled)
This performs multi-headed dot product attention on the given timeseries input
out = concat(head_1, head_2, ..., head_n) * Wo head_i = dot_product_attention(Wq_i*q, Wk_i*k, Wv_i*v) Optionally with normalization when calculating the attention for each head. |
INDArray |
NDMath.neg(INDArray x)
Elementwise negative operation: out = -x
|
INDArray |
NDMath.normalizeMoments(INDArray counts,
INDArray means,
INDArray variances,
double shift)
Calculate the mean and variance from the sufficient statistics
|
INDArray |
NDMath.or(INDArray x,
INDArray y)
Boolean OR operation: elementwise (x !
|
INDArray |
NDBitwise.or(INDArray x,
INDArray y)
Bitwise OR operation.
|
INDArray |
NDMath.pow(INDArray x,
double value)
Element-wise power function: out = x^value
|
INDArray |
NDMath.pow(INDArray x,
INDArray y)
Element-wise (broadcastable) power function: out = x[i]^y[i]
|
INDArray |
NDNN.prelu(INDArray input,
INDArray alpha,
int... sharedAxes)
PReLU (Parameterized Rectified Linear Unit) operation.
|
INDArray |
NDMath.reciprocal(INDArray x)
Element-wise reciprocal (inverse) function: out[i] = 1 / in[i]
|
INDArray |
NDNN.relu(INDArray x,
double cutoff)
Element-wise rectified linear function with specified cutoff:
out[i] = in[i] if in[i] >= cutoff out[i] = 0 otherwise |
INDArray |
NDNN.relu6(INDArray x,
double cutoff)
Element-wise "rectified linear 6" function with specified cutoff:
out[i] = min(max(in, cutoff), 6) |
INDArray |
NDNN.reluLayer(INDArray input,
INDArray weights,
INDArray bias)
ReLU (Rectified Linear Unit) layer operation: out = relu(mmul(in,w) + bias)
Note that bias array is optional |
INDArray |
NDBitwise.rightShift(INDArray x,
INDArray y)
Bitwise right shift operation.
|
INDArray |
NDBitwise.rightShiftCyclic(INDArray x,
INDArray y)
Bitwise right cyclical shift operation.
|
INDArray |
NDMath.round(INDArray x)
Element-wise round function: out = round(x).
|
INDArray |
NDMath.rsqrt(INDArray x)
Element-wise reciprocal (inverse) of square root: out = 1.0 / sqrt(x)
|
INDArray |
NDNN.selu(INDArray x)
Element-wise SeLU function - Scaled exponential Lineal Unit: see Self-Normalizing Neural Networks
out[i] = scale * alpha * (exp(in[i])-1) if in[i]>0, or 0 if in[i] <= 0 Uses default scale and alpha values. |
INDArray |
NDMath.setDiag(INDArray in,
INDArray diag)
Set the diagonal value to the specified values
If input is [ a, b, c] [ d, e, f] [ g, h, i] and diag = [ 1, 2, 3] then output is [ 1, b, c] [ d, 2, f] [ g, h, 3] |
INDArray |
NDMath.shannonEntropy(INDArray in,
int... dimensions)
Shannon Entropy reduction: -sum(x * log2(x))
|
INDArray |
NDNN.sigmoid(INDArray x)
Element-wise sigmoid function: out[i] = 1.0/(1+exp(-in[i]))
|
INDArray |
NDNN.sigmoidDerivative(INDArray x,
INDArray wrt)
Element-wise sigmoid function derivative: dL/dIn given input and dL/dOut
|
INDArray |
NDMath.sign(INDArray x)
Element-wise sign (signum) function:
out = -1 if in < 0 out = 0 if in = 0 out = 1 if in > 0 |
INDArray |
NDMath.sin(INDArray x)
Elementwise sine operation: out = sin(x)
|
INDArray |
NDMath.sinh(INDArray x)
Elementwise sinh (hyperbolic sine) operation: out = sinh(x)
|
INDArray |
NDNN.softmax(INDArray x,
int dimension)
Softmax activation, along the specified dimension
|
INDArray |
NDNN.softmaxDerivative(INDArray x,
INDArray wrt,
int dimension)
Softmax derivative function
|
INDArray |
NDNN.softplus(INDArray x)
Element-wise softplus function: out = log(exp(x) + 1)
|
INDArray |
NDNN.softsign(INDArray x)
Element-wise softsign function: out = x / (abs(x) + 1)
|
INDArray |
NDNN.softsignDerivative(INDArray x)
Element-wise derivative (dOut/dIn) of the softsign function softsign(INDArray)
|
INDArray |
NDMath.sqrt(INDArray x)
Element-wise square root function: out = sqrt(x)
|
INDArray |
NDMath.square(INDArray x)
Element-wise square function: out = x^2
|
INDArray |
NDMath.standardize(INDArray x,
int... dimensions)
Standardize input variable along given axis
out = (x - mean) / stdev with mean and stdev being calculated along the given dimension. |
INDArray |
NDMath.step(INDArray x,
double value)
Elementwise step function:
out(x) = 1 if x >= cutoff out(x) = 0 otherwise |
INDArray |
NDNN.swish(INDArray x)
Element-wise "swish" function: out = x * sigmoid(b*x) with b=1.0
See: https://arxiv.org/abs/1710.05941 |
INDArray |
NDMath.tan(INDArray x)
Elementwise tangent operation: out = tan(x)
|
INDArray |
NDMath.tanh(INDArray x)
Elementwise tanh (hyperbolic tangent) operation: out = tanh(x)
|
INDArray |
NDMath.trace(INDArray in)
Matrix trace operation
For rank 2 matrices, the output is a scalar vith the trace - i.e., sum of the main diagonal. |
INDArray |
NDMath.xor(INDArray x,
INDArray y)
Boolean XOR (exclusive OR) operation: elementwise (x !
|
INDArray |
NDBitwise.xor(INDArray x,
INDArray y)
Bitwise XOR operation (exclusive OR).
|
INDArray |
NDMath.zeroFraction(INDArray input)
Full array zero fraction array reduction operation, optionally along specified dimensions: out = (count(x == 0) / length(x))
|
| Modifier and Type | Method and Description |
|---|---|
static Task |
TaskUtils.buildTask(INDArray array) |
static Task |
TaskUtils.buildTask(INDArray[] array,
INDArray[] labels) |
static Task |
TaskUtils.buildTask(INDArray[] array,
INDArray[] labels) |
static Task |
TaskUtils.buildTask(INDArray array,
INDArray labels) |
| Modifier and Type | Method and Description |
|---|---|
static INDArray |
BooleanIndexing.applyMask(INDArray arr,
INDArray mask)
A minor shortcut for applying a bitmask to
a matrix
|
static INDArray |
BooleanIndexing.applyMaskInPlace(INDArray arr,
INDArray mask)
A minor shortcut for applying a bitmask to
a matrix
|
static INDArray |
BooleanIndexing.chooseFrom(INDArray[] input,
Condition condition)
Choose from the inputs based on the given condition.
|
static INDArray |
BooleanIndexing.chooseFrom(INDArray[] input,
List<Double> tArgs,
List<Integer> iArgs,
Condition condition)
Choose from the inputs based on the given condition.
|
static INDArray |
BooleanIndexing.firstIndex(INDArray array,
Condition condition)
This method returns first index matching given condition
PLEASE NOTE: This method will return -1 value if condition wasn't met
|
static INDArray |
BooleanIndexing.firstIndex(INDArray array,
Condition condition,
int... dimension)
This method returns first index matching given condition along given dimensions
PLEASE NOTE: This method will return -1 values for missing conditions
|
static INDArray |
BooleanIndexing.lastIndex(INDArray array,
Condition condition)
This method returns last index matching given condition
PLEASE NOTE: This method will return -1 value if condition wasn't met
|
static INDArray |
BooleanIndexing.lastIndex(INDArray array,
Condition condition,
int... dimension)
This method returns first index matching given condition along given dimensions
PLEASE NOTE: This method will return -1 values for missing conditions
|
| Modifier and Type | Method and Description |
|---|---|
static INDArrayIndex[] |
NDArrayIndex.allFor(INDArray arr)
Generate an all index
equal to the rank of the given array
|
static boolean |
BooleanIndexing.and(INDArray n,
Condition cond)
And over the whole ndarray given some condition
|
static boolean[] |
BooleanIndexing.and(INDArray n,
Condition condition,
int... dimension)
And over the whole ndarray given some condition, with respect to dimensions
|
static INDArray |
BooleanIndexing.applyMask(INDArray arr,
INDArray mask)
A minor shortcut for applying a bitmask to
a matrix
|
static INDArray |
BooleanIndexing.applyMaskInPlace(INDArray arr,
INDArray mask)
A minor shortcut for applying a bitmask to
a matrix
|
static void |
BooleanIndexing.assignIf(INDArray to,
INDArray from,
Condition condition)
This method does element-wise comparison
for 2 equal-sized matrices, for each element that matches Condition.
|
static INDArray |
BooleanIndexing.chooseFrom(INDArray[] input,
Condition condition)
Choose from the inputs based on the given condition.
|
static INDArray |
BooleanIndexing.chooseFrom(INDArray[] input,
List<Double> tArgs,
List<Integer> iArgs,
Condition condition)
Choose from the inputs based on the given condition.
|
static INDArrayIndex[] |
Indices.createFromStartAndEnd(INDArray start,
INDArray end)
Create an n dimensional index
based on the given interval indices.
|
static INDArrayIndex[] |
Indices.createFromStartAndEnd(INDArray start,
INDArray end,
boolean inclusive)
Create indices representing intervals
along each dimension
|
static INDArray |
BooleanIndexing.firstIndex(INDArray array,
Condition condition)
This method returns first index matching given condition
PLEASE NOTE: This method will return -1 value if condition wasn't met
|
static INDArray |
BooleanIndexing.firstIndex(INDArray array,
Condition condition,
int... dimension)
This method returns first index matching given condition along given dimensions
PLEASE NOTE: This method will return -1 values for missing conditions
|
void |
SpecifiedIndex.init(INDArray arr,
int dimension) |
void |
PointIndex.init(INDArray arr,
int dimension) |
void |
NewAxis.init(INDArray arr,
int dimension) |
void |
NDArrayIndex.init(INDArray arr,
int dimension) |
void |
IntervalIndex.init(INDArray arr,
int dimension) |
void |
INDArrayIndex.init(INDArray arr,
int dimension)
Init the index wrt
the dimension and the given nd array
|
void |
SpecifiedIndex.init(INDArray arr,
long begin,
int dimension) |
void |
PointIndex.init(INDArray arr,
long begin,
int dimension) |
void |
NewAxis.init(INDArray arr,
long begin,
int dimension) |
void |
NDArrayIndexAll.init(INDArray arr,
long begin,
int dimension) |
void |
NDArrayIndex.init(INDArray arr,
long begin,
int dimension) |
void |
IntervalIndex.init(INDArray arr,
long begin,
int dimension) |
void |
INDArrayIndex.init(INDArray arr,
long begin,
int dimension)
Init the index wrt
the dimension and the given nd array
|
static boolean |
Indices.isScalar(INDArray indexOver,
INDArrayIndex... indexes)
Check if the given indexes
over the specified array
are searching for a scalar
|
static INDArray |
BooleanIndexing.lastIndex(INDArray array,
Condition condition)
This method returns last index matching given condition
PLEASE NOTE: This method will return -1 value if condition wasn't met
|
static INDArray |
BooleanIndexing.lastIndex(INDArray array,
Condition condition,
int... dimension)
This method returns first index matching given condition along given dimensions
PLEASE NOTE: This method will return -1 values for missing conditions
|
static long |
Indices.linearOffset(int index,
INDArray arr)
Compute the linear offset
for an index in an ndarray.
|
static long |
NDArrayIndex.offset(INDArray arr,
INDArrayIndex... indices)
Compute the offset given an array of offsets.
|
static long |
NDArrayIndex.offset(INDArray arr,
long... offsets)
Compute the offset given an array of offsets.
|
static boolean |
BooleanIndexing.or(INDArray n,
Condition cond)
Or over the whole ndarray given some condition
|
static boolean[] |
BooleanIndexing.or(INDArray n,
Condition condition,
int... dimension)
Or over the whole ndarray given some condition, with respect to dimensions
|
static void |
BooleanIndexing.replaceWhere(INDArray to,
INDArray from,
Condition condition)
This method does element-wise comparison for 2 equal-sized matrices, for each element that matches Condition
|
static void |
BooleanIndexing.replaceWhere(INDArray to,
Number set,
Condition condition)
This method does element-wise assessing for 2 equal-sized matrices, for each element that matches Condition
|
static INDArrayIndex[] |
NDArrayIndex.resolve(INDArray arr,
INDArrayIndex... intendedIndexes)
Given an all index and
the intended indexes, return an
index array containing a combination of all elements
for slicing and overriding particular indexes where necessary
|
static int |
Indices.rowNumber(int index,
INDArray arr)
Compute the linear offset
for an index in an ndarray.
|
static int[] |
Indices.stride(INDArray arr,
INDArrayIndex[] indexes,
int... shape)
Return the stride to be used for indexing
|
| Modifier and Type | Method and Description |
|---|---|
static INDArray |
InvertMatrix.invert(INDArray arr,
boolean inPlace)
Inverts a matrix
|
static INDArray |
InvertMatrix.pinvert(INDArray arr,
boolean inPlace)
Calculates pseudo inverse of a matrix using QR decomposition
|
static INDArray |
InvertMatrix.pLeftInvert(INDArray arr,
boolean inPlace)
Compute the left pseudo inverse.
|
static INDArray |
InvertMatrix.pRightInvert(INDArray arr,
boolean inPlace)
Compute the right pseudo inverse.
|
| Modifier and Type | Method and Description |
|---|---|
static INDArray |
InvertMatrix.invert(INDArray arr,
boolean inPlace)
Inverts a matrix
|
static INDArray |
InvertMatrix.pinvert(INDArray arr,
boolean inPlace)
Calculates pseudo inverse of a matrix using QR decomposition
|
static INDArray |
InvertMatrix.pLeftInvert(INDArray arr,
boolean inPlace)
Compute the left pseudo inverse.
|
static INDArray |
InvertMatrix.pRightInvert(INDArray arr,
boolean inPlace)
Compute the right pseudo inverse.
|
| Modifier and Type | Field and Description |
|---|---|
INDArray |
AdaGradUpdater.historicalGradient |
| Modifier and Type | Method and Description |
|---|---|
Map<String,INDArray> |
SgdUpdater.getState() |
Map<String,INDArray> |
RmsPropUpdater.getState() |
Map<String,INDArray> |
NoOpUpdater.getState() |
Map<String,INDArray> |
NesterovsUpdater.getState() |
Map<String,INDArray> |
NadamUpdater.getState() |
Map<String,INDArray> |
GradientUpdater.getState() |
Map<String,INDArray> |
AMSGradUpdater.getState() |
Map<String,INDArray> |
AdamUpdater.getState() |
Map<String,INDArray> |
AdaMaxUpdater.getState() |
Map<String,INDArray> |
AdaGradUpdater.getState() |
Map<String,INDArray> |
AdaDeltaUpdater.getState() |
| Modifier and Type | Method and Description |
|---|---|
void |
SgdUpdater.applyUpdater(INDArray gradient,
int iteration,
int epoch) |
void |
RmsPropUpdater.applyUpdater(INDArray gradient,
int iteration,
int epoch) |
void |
NoOpUpdater.applyUpdater(INDArray gradient,
int iteration,
int epoch) |
void |
NesterovsUpdater.applyUpdater(INDArray gradient,
int iteration,
int epoch)
Get the nesterov update
|
void |
NadamUpdater.applyUpdater(INDArray gradient,
int iteration,
int epoch)
Calculate the update based on the given gradient
|
void |
GradientUpdater.applyUpdater(INDArray gradient,
int iteration,
int epoch)
Modify the gradient to be an update.
|
void |
AMSGradUpdater.applyUpdater(INDArray gradient,
int iteration,
int epoch) |
void |
AdamUpdater.applyUpdater(INDArray gradient,
int iteration,
int epoch)
Calculate the update based on the given gradient
|
void |
AdaMaxUpdater.applyUpdater(INDArray gradient,
int iteration,
int epoch)
Calculate the update based on the given gradient
|
void |
AdaGradUpdater.applyUpdater(INDArray gradient,
int iteration,
int epoch)
Gets feature specific learning rates
Adagrad keeps a history of gradients being passed in.
|
void |
AdaDeltaUpdater.applyUpdater(INDArray gradient,
int iteration,
int epoch)
Get the updated gradient for the given gradient
and also update the state of ada delta.
|
void |
SgdUpdater.setStateViewArray(INDArray viewArray,
long[] gradientShape,
char gradientOrder,
boolean initialize) |
void |
RmsPropUpdater.setStateViewArray(INDArray viewArray,
long[] gradientShape,
char gradientOrder,
boolean initialize) |
void |
NoOpUpdater.setStateViewArray(INDArray viewArray,
long[] shape,
char order,
boolean initialize) |
void |
NesterovsUpdater.setStateViewArray(INDArray viewArray,
long[] gradientShape,
char gradientOrder,
boolean initialize) |
void |
NadamUpdater.setStateViewArray(INDArray viewArray,
long[] gradientShape,
char gradientOrder,
boolean initialize) |
void |
GradientUpdater.setStateViewArray(INDArray viewArray,
long[] gradientShape,
char gradientOrder,
boolean initialize)
For the internal updater state (if any): set this to use the provided array.
|
void |
AMSGradUpdater.setStateViewArray(INDArray viewArray,
long[] gradientShape,
char gradientOrder,
boolean initialize) |
void |
AdamUpdater.setStateViewArray(INDArray viewArray,
long[] gradientShape,
char gradientOrder,
boolean initialize) |
void |
AdaMaxUpdater.setStateViewArray(INDArray viewArray,
long[] gradientShape,
char gradientOrder,
boolean initialize) |
void |
AdaGradUpdater.setStateViewArray(INDArray viewArray,
long[] gradientShape,
char gradientOrder,
boolean initialize) |
void |
AdaDeltaUpdater.setStateViewArray(INDArray viewArray,
long[] gradientShape,
char gradientOrder,
boolean initialize) |
| Modifier and Type | Method and Description |
|---|---|
void |
SgdUpdater.setState(Map<String,INDArray> stateMap,
boolean initialize) |
void |
RmsPropUpdater.setState(Map<String,INDArray> stateMap,
boolean initialize) |
void |
NoOpUpdater.setState(Map<String,INDArray> stateMap,
boolean initialize) |
void |
NesterovsUpdater.setState(Map<String,INDArray> stateMap,
boolean initialize) |
void |
NadamUpdater.setState(Map<String,INDArray> stateMap,
boolean initialize) |
void |
GradientUpdater.setState(Map<String,INDArray> stateMap,
boolean initialize) |
void |
AMSGradUpdater.setState(Map<String,INDArray> stateMap,
boolean initialize) |
void |
AdamUpdater.setState(Map<String,INDArray> stateMap,
boolean initialize) |
void |
AdaMaxUpdater.setState(Map<String,INDArray> stateMap,
boolean initialize) |
void |
AdaGradUpdater.setState(Map<String,INDArray> stateMap,
boolean initialize) |
void |
AdaDeltaUpdater.setState(Map<String,INDArray> stateMap,
boolean initialize) |
| Modifier and Type | Method and Description |
|---|---|
GradientUpdater |
Sgd.instantiate(INDArray viewArray,
boolean initializeViewArray) |
GradientUpdater |
RmsProp.instantiate(INDArray viewArray,
boolean initializeViewArray) |
GradientUpdater |
NoOp.instantiate(INDArray viewArray,
boolean initializeViewArray) |
GradientUpdater |
Nesterovs.instantiate(INDArray viewArray,
boolean initializeViewArray) |
GradientUpdater |
Nadam.instantiate(INDArray viewArray,
boolean initializeViewArray) |
GradientUpdater |
IUpdater.instantiate(INDArray viewArray,
boolean initializeViewArray)
Create a new gradient updater
|
GradientUpdater |
AMSGrad.instantiate(INDArray viewArray,
boolean initializeViewArray) |
GradientUpdater |
AdaMax.instantiate(INDArray viewArray,
boolean initializeViewArray) |
GradientUpdater |
Adam.instantiate(INDArray viewArray,
boolean initializeViewArray) |
GradientUpdater |
AdaGrad.instantiate(INDArray viewArray,
boolean initializeViewArray) |
GradientUpdater |
AdaDelta.instantiate(INDArray viewArray,
boolean initializeViewArray) |
| Modifier and Type | Method and Description |
|---|---|
GradientUpdater |
Sgd.instantiate(Map<String,INDArray> updaterState,
boolean initializeStateArrays) |
GradientUpdater |
RmsProp.instantiate(Map<String,INDArray> updaterState,
boolean initializeStateArrays) |
GradientUpdater |
NoOp.instantiate(Map<String,INDArray> updaterState,
boolean initializeStateArrays) |
GradientUpdater |
Nesterovs.instantiate(Map<String,INDArray> updaterState,
boolean initializeStateArrays) |
GradientUpdater |
Nadam.instantiate(Map<String,INDArray> updaterState,
boolean initializeStateArrays) |
GradientUpdater |
IUpdater.instantiate(Map<String,INDArray> updaterState,
boolean initializeStateArrays) |
GradientUpdater |
AMSGrad.instantiate(Map<String,INDArray> updaterState,
boolean initializeStateArrays) |
GradientUpdater |
AdaMax.instantiate(Map<String,INDArray> updaterState,
boolean initializeStateArrays) |
GradientUpdater |
Adam.instantiate(Map<String,INDArray> updaterState,
boolean initializeStateArrays) |
GradientUpdater |
AdaGrad.instantiate(Map<String,INDArray> updaterState,
boolean initializeStateArrays) |
GradientUpdater |
AdaDelta.instantiate(Map<String,INDArray> updaterState,
boolean initializeStateArrays) |
| Modifier and Type | Field and Description |
|---|---|
INDArray |
AdaGrad.historicalGradient |
| Modifier and Type | Method and Description |
|---|---|
INDArray |
AdaGrad.getGradient(INDArray gradient,
int iteration)
Gets feature specific learning rates
Adagrad keeps a history of gradients being passed in.
|
INDArray |
AdaGrad.getGradient(INDArray gradient,
int slice,
long[] shape) |
| Modifier and Type | Method and Description |
|---|---|
INDArray |
AdaGrad.getGradient(INDArray gradient,
int iteration)
Gets feature specific learning rates
Adagrad keeps a history of gradients being passed in.
|
INDArray |
AdaGrad.getGradient(INDArray gradient,
int slice,
long[] shape) |
void |
AdaGrad.setStateViewArray(INDArray viewArray,
int[] gradientShape,
char gradientOrder,
boolean initialize) |
void |
AdaGrad.setStateViewArray(INDArray viewArray,
long[] gradientShape,
char gradientOrder,
boolean initialize) |
| Modifier and Type | Method and Description |
|---|---|
void |
WeightDecay.apply(INDArray param,
INDArray gradView,
double lr,
int iteration,
int epoch) |
void |
Regularization.apply(INDArray param,
INDArray gradView,
double lr,
int iteration,
int epoch)
Apply the regularization by modifying the gradient array in-place
|
void |
L2Regularization.apply(INDArray param,
INDArray gradView,
double lr,
int iteration,
int epoch) |
void |
L1Regularization.apply(INDArray param,
INDArray gradView,
double lr,
int iteration,
int epoch) |
double |
WeightDecay.score(INDArray param,
int iteration,
int epoch) |
double |
Regularization.score(INDArray param,
int iteration,
int epoch)
Calculate the loss function score component for the regularization.
|
double |
L2Regularization.score(INDArray param,
int iteration,
int epoch) |
double |
L1Regularization.score(INDArray param,
int iteration,
int epoch) |
| Modifier and Type | Method and Description |
|---|---|
INDArray |
ILossFunction.computeGradient(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask)
Compute the gradient of the loss function with respect to the inputs: dL/dOutput
|
INDArray |
ILossFunction.computeScoreArray(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask)
Compute the score (loss function value) for each example individually.
|
| Modifier and Type | Method and Description |
|---|---|
Pair<Double,INDArray> |
ILossFunction.computeGradientAndScore(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask,
boolean average)
Compute both the score (loss function value) and gradient.
|
| Modifier and Type | Method and Description |
|---|---|
static void |
LossUtil.applyMask(INDArray to,
INDArray mask) |
INDArray |
ILossFunction.computeGradient(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask)
Compute the gradient of the loss function with respect to the inputs: dL/dOutput
|
Pair<Double,INDArray> |
ILossFunction.computeGradientAndScore(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask,
boolean average)
Compute both the score (loss function value) and gradient.
|
double |
ILossFunction.computeScore(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask,
boolean average)
Compute the score (loss function value) for the given inputs.
|
INDArray |
ILossFunction.computeScoreArray(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask)
Compute the score (loss function value) for each example individually.
|
static boolean |
LossUtil.isPerOutputMasking(INDArray to,
INDArray mask) |
| Modifier and Type | Field and Description |
|---|---|
protected INDArray |
LossMCXENT.weights |
protected INDArray |
LossL2.weights |
protected INDArray |
LossL1.weights |
| Modifier and Type | Method and Description |
|---|---|
INDArray |
LossWasserstein.computeGradient(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask) |
INDArray |
LossSquaredHinge.computeGradient(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask) |
INDArray |
LossSparseMCXENT.computeGradient(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask) |
INDArray |
LossPoisson.computeGradient(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask) |
INDArray |
LossMultiLabel.computeGradient(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask) |
INDArray |
LossMSLE.computeGradient(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask) |
INDArray |
LossMSE.computeGradient(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask) |
INDArray |
LossMixtureDensity.computeGradient(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask)
This method returns the gradient of the cost function with respect to the
output from the previous layer.
|
INDArray |
LossMCXENT.computeGradient(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask) |
INDArray |
LossMAPE.computeGradient(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask) |
INDArray |
LossMAE.computeGradient(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask) |
INDArray |
LossL2.computeGradient(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask) |
INDArray |
LossL1.computeGradient(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask) |
INDArray |
LossKLD.computeGradient(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask) |
INDArray |
LossHinge.computeGradient(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask) |
INDArray |
LossFMeasure.computeGradient(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask) |
INDArray |
LossCosineProximity.computeGradient(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask) |
INDArray |
LossBinaryXENT.computeGradient(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask) |
INDArray |
LossWasserstein.computeScoreArray(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask) |
INDArray |
LossSquaredHinge.computeScoreArray(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask) |
INDArray |
LossSparseMCXENT.computeScoreArray(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask) |
INDArray |
LossPoisson.computeScoreArray(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask) |
INDArray |
LossMultiLabel.computeScoreArray(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask) |
INDArray |
LossMSLE.computeScoreArray(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask) |
INDArray |
LossMSE.computeScoreArray(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask) |
INDArray |
LossMixtureDensity.computeScoreArray(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask)
This method returns the score for each of the given outputs against the
given set of labels.
|
INDArray |
LossMCXENT.computeScoreArray(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask) |
INDArray |
LossMAPE.computeScoreArray(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask) |
INDArray |
LossMAE.computeScoreArray(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask) |
INDArray |
LossL2.computeScoreArray(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask) |
INDArray |
LossL1.computeScoreArray(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask) |
INDArray |
LossKLD.computeScoreArray(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask) |
INDArray |
LossHinge.computeScoreArray(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask) |
INDArray |
LossFMeasure.computeScoreArray(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask) |
INDArray |
LossCosineProximity.computeScoreArray(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask) |
INDArray |
LossBinaryXENT.computeScoreArray(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask) |
INDArray |
LossSquaredHinge.scoreArray(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask) |
INDArray |
LossPoisson.scoreArray(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask) |
INDArray |
LossMultiLabel.scoreArray(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask) |
INDArray |
LossMSLE.scoreArray(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask) |
protected INDArray |
LossMCXENT.scoreArray(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask) |
INDArray |
LossMAPE.scoreArray(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask) |
protected INDArray |
LossL2.scoreArray(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask) |
INDArray |
LossL1.scoreArray(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask) |
INDArray |
LossHinge.scoreArray(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask) |
INDArray |
LossCosineProximity.scoreArray(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask) |
protected INDArray |
LossSparseMCXENT.sparseScoreArray(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask) |
| Modifier and Type | Method and Description |
|---|---|
Pair<Double,INDArray> |
LossWasserstein.computeGradientAndScore(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask,
boolean average) |
Pair<Double,INDArray> |
LossSquaredHinge.computeGradientAndScore(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask,
boolean average) |
Pair<Double,INDArray> |
LossSparseMCXENT.computeGradientAndScore(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask,
boolean average) |
Pair<Double,INDArray> |
LossPoisson.computeGradientAndScore(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask,
boolean average) |
Pair<Double,INDArray> |
LossMultiLabel.computeGradientAndScore(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask,
boolean average) |
Pair<Double,INDArray> |
LossMSLE.computeGradientAndScore(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask,
boolean average) |
Pair<Double,INDArray> |
LossMixtureDensity.computeGradientAndScore(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask,
boolean average) |
Pair<Double,INDArray> |
LossMCXENT.computeGradientAndScore(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask,
boolean average) |
Pair<Double,INDArray> |
LossMAPE.computeGradientAndScore(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask,
boolean average) |
Pair<Double,INDArray> |
LossL2.computeGradientAndScore(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask,
boolean average) |
Pair<Double,INDArray> |
LossL1.computeGradientAndScore(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask,
boolean average) |
Pair<Double,INDArray> |
LossKLD.computeGradientAndScore(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask,
boolean average) |
Pair<Double,INDArray> |
LossHinge.computeGradientAndScore(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask,
boolean average) |
Pair<Double,INDArray> |
LossFMeasure.computeGradientAndScore(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask,
boolean average) |
Pair<Double,INDArray> |
LossCosineProximity.computeGradientAndScore(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask,
boolean average) |
Pair<Double,INDArray> |
LossBinaryXENT.computeGradientAndScore(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask,
boolean average) |
| Modifier and Type | Method and Description |
|---|---|
INDArray |
LossWasserstein.computeGradient(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask) |
INDArray |
LossSquaredHinge.computeGradient(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask) |
INDArray |
LossSparseMCXENT.computeGradient(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask) |
INDArray |
LossPoisson.computeGradient(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask) |
INDArray |
LossMultiLabel.computeGradient(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask) |
INDArray |
LossMSLE.computeGradient(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask) |
INDArray |
LossMSE.computeGradient(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask) |
INDArray |
LossMixtureDensity.computeGradient(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask)
This method returns the gradient of the cost function with respect to the
output from the previous layer.
|
INDArray |
LossMCXENT.computeGradient(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask) |
INDArray |
LossMAPE.computeGradient(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask) |
INDArray |
LossMAE.computeGradient(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask) |
INDArray |
LossL2.computeGradient(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask) |
INDArray |
LossL1.computeGradient(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask) |
INDArray |
LossKLD.computeGradient(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask) |
INDArray |
LossHinge.computeGradient(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask) |
INDArray |
LossFMeasure.computeGradient(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask) |
INDArray |
LossCosineProximity.computeGradient(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask) |
INDArray |
LossBinaryXENT.computeGradient(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask) |
Pair<Double,INDArray> |
LossWasserstein.computeGradientAndScore(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask,
boolean average) |
Pair<Double,INDArray> |
LossSquaredHinge.computeGradientAndScore(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask,
boolean average) |
Pair<Double,INDArray> |
LossSparseMCXENT.computeGradientAndScore(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask,
boolean average) |
Pair<Double,INDArray> |
LossPoisson.computeGradientAndScore(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask,
boolean average) |
Pair<Double,INDArray> |
LossMultiLabel.computeGradientAndScore(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask,
boolean average) |
Pair<Double,INDArray> |
LossMSLE.computeGradientAndScore(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask,
boolean average) |
Pair<Double,INDArray> |
LossMixtureDensity.computeGradientAndScore(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask,
boolean average) |
Pair<Double,INDArray> |
LossMCXENT.computeGradientAndScore(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask,
boolean average) |
Pair<Double,INDArray> |
LossMAPE.computeGradientAndScore(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask,
boolean average) |
Pair<Double,INDArray> |
LossL2.computeGradientAndScore(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask,
boolean average) |
Pair<Double,INDArray> |
LossL1.computeGradientAndScore(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask,
boolean average) |
Pair<Double,INDArray> |
LossKLD.computeGradientAndScore(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask,
boolean average) |
Pair<Double,INDArray> |
LossHinge.computeGradientAndScore(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask,
boolean average) |
Pair<Double,INDArray> |
LossFMeasure.computeGradientAndScore(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask,
boolean average) |
Pair<Double,INDArray> |
LossCosineProximity.computeGradientAndScore(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask,
boolean average) |
Pair<Double,INDArray> |
LossBinaryXENT.computeGradientAndScore(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask,
boolean average) |
double |
LossWasserstein.computeScore(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask,
boolean average) |
double |
LossSquaredHinge.computeScore(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask,
boolean average) |
double |
LossSparseMCXENT.computeScore(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask,
boolean average) |
double |
LossPoisson.computeScore(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask,
boolean average) |
double |
LossMultiLabel.computeScore(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask,
boolean average) |
double |
LossMSLE.computeScore(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask,
boolean average) |
double |
LossMSE.computeScore(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask,
boolean average) |
double |
LossMixtureDensity.computeScore(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask,
boolean average)
Computes the aggregate score as a sum of all of the individual scores of
each of the labels against each of the outputs of the network.
|
double |
LossMCXENT.computeScore(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask,
boolean average) |
double |
LossMAPE.computeScore(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask,
boolean average) |
double |
LossMAE.computeScore(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask,
boolean average) |
double |
LossL2.computeScore(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask,
boolean average) |
double |
LossL1.computeScore(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask,
boolean average) |
double |
LossKLD.computeScore(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask,
boolean average) |
double |
LossHinge.computeScore(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask,
boolean average) |
double |
LossFMeasure.computeScore(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask,
boolean average) |
double |
LossCosineProximity.computeScore(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask,
boolean average) |
double |
LossBinaryXENT.computeScore(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask,
boolean average) |
INDArray |
LossWasserstein.computeScoreArray(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask) |
INDArray |
LossSquaredHinge.computeScoreArray(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask) |
INDArray |
LossSparseMCXENT.computeScoreArray(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask) |
INDArray |
LossPoisson.computeScoreArray(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask) |
INDArray |
LossMultiLabel.computeScoreArray(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask) |
INDArray |
LossMSLE.computeScoreArray(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask) |
INDArray |
LossMSE.computeScoreArray(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask) |
INDArray |
LossMixtureDensity.computeScoreArray(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask)
This method returns the score for each of the given outputs against the
given set of labels.
|
INDArray |
LossMCXENT.computeScoreArray(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask) |
INDArray |
LossMAPE.computeScoreArray(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask) |
INDArray |
LossMAE.computeScoreArray(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask) |
INDArray |
LossL2.computeScoreArray(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask) |
INDArray |
LossL1.computeScoreArray(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask) |
INDArray |
LossKLD.computeScoreArray(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask) |
INDArray |
LossHinge.computeScoreArray(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask) |
INDArray |
LossFMeasure.computeScoreArray(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask) |
INDArray |
LossCosineProximity.computeScoreArray(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask) |
INDArray |
LossBinaryXENT.computeScoreArray(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask) |
LossMixtureDensity.MixtureDensityComponents |
LossMixtureDensity.extractComponents(INDArray output) |
INDArray |
LossSquaredHinge.scoreArray(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask) |
INDArray |
LossPoisson.scoreArray(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask) |
INDArray |
LossMultiLabel.scoreArray(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask) |
INDArray |
LossMSLE.scoreArray(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask) |
protected INDArray |
LossMCXENT.scoreArray(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask) |
INDArray |
LossMAPE.scoreArray(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask) |
protected INDArray |
LossL2.scoreArray(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask) |
INDArray |
LossL1.scoreArray(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask) |
INDArray |
LossHinge.scoreArray(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask) |
INDArray |
LossCosineProximity.scoreArray(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask) |
protected INDArray |
LossSparseMCXENT.sparseScoreArray(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask) |
| Constructor and Description |
|---|
LossBinaryXENT(double clipEps,
INDArray weights)
Binary cross entropy where each the output is
(optionally) weighted/scaled by a fixed scalar value.
|
LossBinaryXENT(INDArray weights)
Binary cross entropy where each the output is
(optionally) weighted/scaled by a fixed scalar value.
|
LossL1(INDArray weights)
L1 loss function where each the output is (optionally) weighted/scaled by a flags scalar value.
|
LossL2(INDArray weights)
L2 loss function where each the output is (optionally) weighted/scaled by a flags scalar value.
|
LossMAE(INDArray weights)
Mean Absolute Error loss function where each the output is (optionally) weighted/scaled by a flags scalar value.
|
LossMAPE(INDArray weights)
Mean Absolute Percentage Error loss function where each the output is (optionally) weighted/scaled by a flags scalar value.
|
LossMCXENT(double softmaxClipEps,
INDArray weights)
Multi-Class Cross Entropy loss function where each the output is (optionally) weighted/scaled by a fixed scalar value.
|
LossMCXENT(INDArray weights)
Multi-Class Cross Entropy loss function where each the output is (optionally) weighted/scaled by a flags scalar value.
|
LossMSE(INDArray weights)
Mean Squared Error loss function where each the output is (optionally) weighted/scaled by a flags scalar value.
|
LossMSLE(INDArray weights)
Mean Squared Logarithmic Error loss function where each the output is (optionally) weighted/scaled by a flags scalar value.
|
LossNegativeLogLikelihood(INDArray weights) |
LossSparseMCXENT(double softmaxClipEps,
INDArray weights)
Multi-Class Cross Entropy loss function where each the output is (optionally) weighted/scaled by a fixed scalar value.
|
LossSparseMCXENT(INDArray weights)
Multi-Class Cross Entropy loss function where each the output is (optionally) weighted/scaled by a flags scalar value.
|
| Modifier and Type | Method and Description |
|---|---|
INDArray |
RowVectorDeserializer.deserialize(org.nd4j.shade.jackson.core.JsonParser jsonParser,
org.nd4j.shade.jackson.databind.DeserializationContext deserializationContext)
Deprecated.
|
| Modifier and Type | Method and Description |
|---|---|
void |
RowVectorSerializer.serialize(INDArray array,
org.nd4j.shade.jackson.core.JsonGenerator jsonGenerator,
org.nd4j.shade.jackson.databind.SerializerProvider serializerProvider)
Deprecated.
|
| Modifier and Type | Method and Description |
|---|---|
void |
MemoryManager.collect(INDArray... arrays)
This method detaches off-heap memory from passed INDArray instances, and optionally stores them in cache for future reuse
PLEASE NOTE: Cache options depend on specific implementations
|
void |
BasicMemoryManager.collect(INDArray... arrays)
This method detaches off-heap memory from passed INDArray instances, and optionally stores them in cache for future reuse
PLEASE NOTE: Cache options depend on specific implementations
|
void |
MemoryManager.memset(INDArray array)
This method fills given INDArray with zeroes.
|
| Modifier and Type | Field and Description |
|---|---|
protected Map<T,INDArray> |
BasicStash.stash |
| Modifier and Type | Method and Description |
|---|---|
INDArray |
Stash.get(T key) |
INDArray |
BasicStash.get(T key) |
| Modifier and Type | Method and Description |
|---|---|
void |
Stash.put(T key,
INDArray object) |
void |
BasicStash.put(T key,
INDArray object) |
| Modifier and Type | Method and Description |
|---|---|
static INDArray |
Transforms.abs(INDArray ndArray)
Abs function
|
static INDArray |
Transforms.abs(INDArray ndArray,
boolean dup)
Abs function
|
static INDArray |
Transforms.acos(INDArray arr) |
static INDArray |
Transforms.acos(INDArray in,
boolean copy) |
static INDArray |
Transforms.allCosineDistances(INDArray d1,
INDArray d2,
int... dimensions) |
static INDArray |
Transforms.allCosineSimilarities(INDArray d1,
INDArray d2,
int... dimensions) |
static INDArray |
Transforms.allEuclideanDistances(INDArray d1,
INDArray d2,
int... dimensions) |
static INDArray |
Transforms.allManhattanDistances(INDArray d1,
INDArray d2,
int... dimensions) |
static INDArray |
Transforms.and(INDArray x,
INDArray y) |
static INDArray |
Transforms.asin(INDArray arr) |
static INDArray |
Transforms.asin(INDArray in,
boolean copy) |
static INDArray |
Transforms.atan(INDArray arr) |
static INDArray |
Transforms.atan(INDArray in,
boolean copy) |
static INDArray |
Transforms.atan2(INDArray x,
INDArray y)
Atan2 operation, new INDArray instance will be returned
Note the order of x and y parameters is opposite to that of
Math.atan2(double, double) |
static INDArray |
Transforms.atanh(INDArray in)
Sin function
|
static INDArray |
Transforms.atanh(INDArray in,
boolean copy)
Sin function
|
static INDArray |
Transforms.ceil(INDArray arr) |
static INDArray |
Transforms.ceil(INDArray in,
boolean copy) |
static INDArray |
Transforms.ceiling(INDArray ndArray)
Binary matrix of whether the number at a given index is greater than
|
static INDArray |
Transforms.ceiling(INDArray ndArray,
boolean copyOnOps)
Ceiling function
|
static INDArray |
Transforms.cos(INDArray in) |
static INDArray |
Transforms.cos(INDArray in,
boolean copy) |
static INDArray |
Transforms.cosh(INDArray in) |
static INDArray |
Transforms.cosh(INDArray in,
boolean copy) |
static INDArray |
Transforms.cross(INDArray x,
INDArray y) |
static INDArray |
Transforms.dot(INDArray x,
INDArray y)
Dot product, new INDArray instance will be returned.
|
static INDArray |
Transforms.elu(INDArray arr) |
static INDArray |
Transforms.elu(INDArray in,
boolean copy) |
static INDArray |
Transforms.eluDerivative(INDArray arr,
INDArray grad) |
static INDArray |
Transforms.eluDerivative(INDArray in,
INDArray grad,
boolean copy) |
static INDArray |
Transforms.eps(INDArray ndArray) |
static INDArray |
Transforms.exp(INDArray ndArray)
Run the exp operation
|
static INDArray |
Transforms.exp(INDArray ndArray,
boolean dup)
Exp function
|
static INDArray |
Transforms.expm1(INDArray ndArray,
boolean dup)
Elementwise exponential - 1 function
|
static INDArray |
Transforms.floor(INDArray ndArray)
Binary matrix of whether the number at a given index is greater than
|
static INDArray |
Transforms.floor(INDArray ndArray,
boolean dup)
Floor function
|
static INDArray |
Transforms.greaterThanOrEqual(INDArray first,
INDArray ndArray)
1 if greater than or equal to 0 otherwise (at each element)
|
static INDArray |
Transforms.greaterThanOrEqual(INDArray first,
INDArray ndArray,
boolean dup)
Eps function
|
static INDArray |
Transforms.hardSigmoid(INDArray arr,
boolean dup) |
static INDArray |
Transforms.hardTanh(INDArray ndArray) |
static INDArray |
Transforms.hardTanh(INDArray ndArray,
boolean dup)
Hard tanh
|
static INDArray |
Transforms.hardTanhDerivative(INDArray ndArray) |
static INDArray |
Transforms.hardTanhDerivative(INDArray ndArray,
boolean dup)
Hard tanh
|
static INDArray |
Transforms.identity(INDArray ndArray) |
static INDArray |
Transforms.identity(INDArray ndArray,
boolean dup)
Identity function
|
static INDArray |
Transforms.isMax(INDArray input) |
static INDArray |
Transforms.isMax(INDArray input,
DataType dataType) |
static INDArray |
Transforms.isMax(INDArray input,
INDArray output) |
static INDArray |
Transforms.leakyRelu(INDArray arr) |
static INDArray |
Transforms.leakyRelu(INDArray in,
boolean copy) |
static INDArray |
Transforms.leakyRelu(INDArray arr,
double cutoff) |
static INDArray |
Transforms.leakyRelu(INDArray in,
double cutoff,
boolean copy) |
static INDArray |
Transforms.leakyReluDerivative(INDArray arr,
double cutoff) |
static INDArray |
Transforms.leakyReluDerivative(INDArray in,
double cutoff,
boolean copy) |
static INDArray |
Transforms.lessThanOrEqual(INDArray first,
INDArray ndArray)
1 if less than or equal to 0 otherwise (at each element)
|
static INDArray |
Transforms.lessThanOrEqual(INDArray first,
INDArray ndArray,
boolean dup)
Eps function
|
static INDArray |
Transforms.log(INDArray ndArray) |
static INDArray |
Transforms.log(INDArray ndArray,
boolean dup)
Log function
|
static INDArray |
Transforms.log(INDArray ndArray,
double base)
Log on arbitrary base
|
static INDArray |
Transforms.log(INDArray ndArray,
double base,
boolean duplicate)
Log on arbitrary base
|
static INDArray |
Transforms.log1p(INDArray ndArray,
boolean dup)
Log of x + 1 function
|
static INDArray |
Transforms.max(INDArray ndArray,
double k)
Maximum function with a scalar
|
static INDArray |
Transforms.max(INDArray ndArray,
double k,
boolean dup)
Maximum function with a scalar
|
static INDArray |
Transforms.max(INDArray first,
INDArray second)
Element wise maximum function between 2 INDArrays
|
static INDArray |
Transforms.max(INDArray first,
INDArray second,
boolean dup)
Element wise maximum function between 2 INDArrays
|
static INDArray |
Transforms.min(INDArray ndArray,
double k)
Maximum function with a scalar
|
static INDArray |
Transforms.min(INDArray ndArray,
double k,
boolean dup)
Minimum function with a scalar
|
static INDArray |
Transforms.min(INDArray first,
INDArray second)
Element wise minimum function between 2 INDArrays
|
static INDArray |
Transforms.min(INDArray first,
INDArray second,
boolean dup)
Element wise minimum function between 2 INDArrays
|
static INDArray |
Transforms.mpow(INDArray in,
int n,
boolean dup)
Raises a square matrix to a power n, which can be positive, negative, or zero.
|
static INDArray |
Transforms.neg(INDArray ndArray)
Returns the negative of an ndarray
|
static INDArray |
Transforms.neg(INDArray ndArray,
boolean dup)
Negative
|
static INDArray |
Transforms.normalizeZeroMeanAndUnitVariance(INDArray toNormalize)
Normalize data to zero mean and unit variance
substract by the mean and divide by the standard deviation
|
static INDArray |
Transforms.not(INDArray x) |
static INDArray |
Transforms.or(INDArray x,
INDArray y) |
static INDArray |
Transforms.pow(INDArray ndArray,
INDArray power)
Element-wise power function - x^y, performed element-wise.
|
static INDArray |
Transforms.pow(INDArray ndArray,
INDArray power,
boolean dup)
Element-wise power function - x^y, performed element-wise
|
static INDArray |
Transforms.pow(INDArray ndArray,
Number power)
Pow function
|
static INDArray |
Transforms.pow(INDArray ndArray,
Number power,
boolean dup)
Pow function
|
static INDArray |
Transforms.relu(INDArray arr) |
static INDArray |
Transforms.relu(INDArray in,
boolean copy) |
static INDArray |
Transforms.relu6(INDArray arr) |
static INDArray |
Transforms.relu6(INDArray in,
boolean copy) |
static INDArray |
Transforms.reverse(INDArray x,
boolean dup) |
static INDArray |
Transforms.round(INDArray ndArray)
Rounding function
|
static INDArray |
Transforms.round(INDArray ndArray,
boolean dup)
Rounding function
|
static INDArray |
Transforms.sigmoid(INDArray ndArray)
Sigmoid function
|
static INDArray |
Transforms.sigmoid(INDArray ndArray,
boolean dup)
Sigmoid function
|
static INDArray |
Transforms.sigmoidDerivative(INDArray ndArray)
Sigmoid function
|
static INDArray |
Transforms.sigmoidDerivative(INDArray ndArray,
boolean dup)
Sigmoid function
|
static INDArray |
Transforms.sign(INDArray toSign)
Signum function of this ndarray
|
static INDArray |
Transforms.sign(INDArray toSign,
boolean dup)
Signum function of this ndarray
|
static INDArray |
Transforms.sin(INDArray in)
Sin function
|
static INDArray |
Transforms.sin(INDArray in,
boolean copy)
Sin function
|
static INDArray |
Transforms.sinh(INDArray in)
Sinh function
|
static INDArray |
Transforms.sinh(INDArray in,
boolean copy)
Sinh function
|
static INDArray |
Transforms.softmax(INDArray arr) |
static INDArray |
Transforms.softmax(INDArray in,
boolean copy) |
static INDArray |
Transforms.softPlus(INDArray arr) |
static INDArray |
Transforms.softPlus(INDArray in,
boolean copy) |
static INDArray |
Transforms.softsign(INDArray arr) |
static INDArray |
Transforms.softsign(INDArray in,
boolean copy) |
static INDArray |
Transforms.softsignDerivative(INDArray arr) |
static INDArray |
Transforms.softsignDerivative(INDArray in,
boolean copy) |
static INDArray |
Transforms.sqrt(INDArray ndArray)
Sqrt function
|
static INDArray |
Transforms.sqrt(INDArray ndArray,
boolean dup)
Sqrt function
|
static INDArray |
Transforms.stabilize(INDArray ndArray,
double k) |
static INDArray |
Transforms.stabilize(INDArray ndArray,
double k,
boolean dup)
Stabilize to be within a range of k
|
static INDArray |
Transforms.step(INDArray arr) |
static INDArray |
Transforms.step(INDArray in,
boolean copy) |
static INDArray |
Transforms.tan(INDArray ndArray)
Element-wise tan function.
|
static INDArray |
Transforms.tan(INDArray ndArray,
boolean dup)
Element-wise tan function.
|
static INDArray |
Transforms.tanh(INDArray ndArray)
Tanh function
|
static INDArray |
Transforms.tanh(INDArray ndArray,
boolean dup)
Tanh function
|
static INDArray |
Transforms.timesOneMinus(INDArray in,
boolean copy)
out = in * (1-in)
|
static INDArray |
Transforms.unitVec(INDArray toScale)
Scale by 1 / norm2 of the matrix
|
static INDArray |
Transforms.xor(INDArray x,
INDArray y) |
| Modifier and Type | Method and Description |
|---|---|
static INDArray |
Transforms.abs(INDArray ndArray)
Abs function
|
static INDArray |
Transforms.abs(INDArray ndArray,
boolean dup)
Abs function
|
static INDArray |
Transforms.acos(INDArray arr) |
static INDArray |
Transforms.acos(INDArray in,
boolean copy) |
static INDArray |
Transforms.allCosineDistances(INDArray d1,
INDArray d2,
int... dimensions) |
static INDArray |
Transforms.allCosineSimilarities(INDArray d1,
INDArray d2,
int... dimensions) |
static INDArray |
Transforms.allEuclideanDistances(INDArray d1,
INDArray d2,
int... dimensions) |
static INDArray |
Transforms.allManhattanDistances(INDArray d1,
INDArray d2,
int... dimensions) |
static INDArray |
Transforms.and(INDArray x,
INDArray y) |
static INDArray |
Transforms.asin(INDArray arr) |
static INDArray |
Transforms.asin(INDArray in,
boolean copy) |
static INDArray |
Transforms.atan(INDArray arr) |
static INDArray |
Transforms.atan(INDArray in,
boolean copy) |
static INDArray |
Transforms.atan2(INDArray x,
INDArray y)
Atan2 operation, new INDArray instance will be returned
Note the order of x and y parameters is opposite to that of
Math.atan2(double, double) |
static INDArray |
Transforms.atanh(INDArray in)
Sin function
|
static INDArray |
Transforms.atanh(INDArray in,
boolean copy)
Sin function
|
protected static long[] |
Transforms.broadcastResultShape(INDArray first,
INDArray second) |
static INDArray |
Transforms.ceil(INDArray arr) |
static INDArray |
Transforms.ceil(INDArray in,
boolean copy) |
static INDArray |
Transforms.ceiling(INDArray ndArray)
Binary matrix of whether the number at a given index is greater than
|
static INDArray |
Transforms.ceiling(INDArray ndArray,
boolean copyOnOps)
Ceiling function
|
static INDArray |
Transforms.cos(INDArray in) |
static INDArray |
Transforms.cos(INDArray in,
boolean copy) |
static INDArray |
Transforms.cosh(INDArray in) |
static INDArray |
Transforms.cosh(INDArray in,
boolean copy) |
static double |
Transforms.cosineDistance(INDArray d1,
INDArray d2) |
static double |
Transforms.cosineSim(INDArray d1,
INDArray d2)
Cosine similarity
|
static INDArray |
Transforms.cross(INDArray x,
INDArray y) |
static INDArray |
Transforms.dot(INDArray x,
INDArray y)
Dot product, new INDArray instance will be returned.
|
static INDArray |
Transforms.elu(INDArray arr) |
static INDArray |
Transforms.elu(INDArray in,
boolean copy) |
static INDArray |
Transforms.eluDerivative(INDArray arr,
INDArray grad) |
static INDArray |
Transforms.eluDerivative(INDArray in,
INDArray grad,
boolean copy) |
static INDArray |
Transforms.eps(INDArray ndArray) |
static double |
Transforms.euclideanDistance(INDArray d1,
INDArray d2) |
static INDArray |
Transforms.exp(INDArray ndArray)
Run the exp operation
|
static INDArray |
Transforms.exp(INDArray ndArray,
boolean dup)
Exp function
|
static INDArray |
Transforms.expm1(INDArray ndArray,
boolean dup)
Elementwise exponential - 1 function
|
static INDArray |
Transforms.floor(INDArray ndArray)
Binary matrix of whether the number at a given index is greater than
|
static INDArray |
Transforms.floor(INDArray ndArray,
boolean dup)
Floor function
|
static INDArray |
Transforms.greaterThanOrEqual(INDArray first,
INDArray ndArray)
1 if greater than or equal to 0 otherwise (at each element)
|
static INDArray |
Transforms.greaterThanOrEqual(INDArray first,
INDArray ndArray,
boolean dup)
Eps function
|
static double |
Transforms.hammingDistance(INDArray d1,
INDArray d2) |
static INDArray |
Transforms.hardSigmoid(INDArray arr,
boolean dup) |
static INDArray |
Transforms.hardTanh(INDArray ndArray) |
static INDArray |
Transforms.hardTanh(INDArray ndArray,
boolean dup)
Hard tanh
|
static INDArray |
Transforms.hardTanhDerivative(INDArray ndArray) |
static INDArray |
Transforms.hardTanhDerivative(INDArray ndArray,
boolean dup)
Hard tanh
|
static INDArray |
Transforms.identity(INDArray ndArray) |
static INDArray |
Transforms.identity(INDArray ndArray,
boolean dup)
Identity function
|
static INDArray |
Transforms.isMax(INDArray input) |
static INDArray |
Transforms.isMax(INDArray input,
DataType dataType) |
static INDArray |
Transforms.isMax(INDArray input,
INDArray output) |
static double |
Transforms.jaccardDistance(INDArray d1,
INDArray d2) |
static INDArray |
Transforms.leakyRelu(INDArray arr) |
static INDArray |
Transforms.leakyRelu(INDArray in,
boolean copy) |
static INDArray |
Transforms.leakyRelu(INDArray arr,
double cutoff) |
static INDArray |
Transforms.leakyRelu(INDArray in,
double cutoff,
boolean copy) |
static INDArray |
Transforms.leakyReluDerivative(INDArray arr,
double cutoff) |
static INDArray |
Transforms.leakyReluDerivative(INDArray in,
double cutoff,
boolean copy) |
static INDArray |
Transforms.lessThanOrEqual(INDArray first,
INDArray ndArray)
1 if less than or equal to 0 otherwise (at each element)
|
static INDArray |
Transforms.lessThanOrEqual(INDArray first,
INDArray ndArray,
boolean dup)
Eps function
|
static INDArray |
Transforms.log(INDArray ndArray) |
static INDArray |
Transforms.log(INDArray ndArray,
boolean dup)
Log function
|
static INDArray |
Transforms.log(INDArray ndArray,
double base)
Log on arbitrary base
|
static INDArray |
Transforms.log(INDArray ndArray,
double base,
boolean duplicate)
Log on arbitrary base
|
static INDArray |
Transforms.log1p(INDArray ndArray,
boolean dup)
Log of x + 1 function
|
static double |
Transforms.manhattanDistance(INDArray d1,
INDArray d2) |
static INDArray |
Transforms.max(INDArray ndArray,
double k)
Maximum function with a scalar
|
static INDArray |
Transforms.max(INDArray ndArray,
double k,
boolean dup)
Maximum function with a scalar
|
static INDArray |
Transforms.max(INDArray first,
INDArray second)
Element wise maximum function between 2 INDArrays
|
static INDArray |
Transforms.max(INDArray first,
INDArray second,
boolean dup)
Element wise maximum function between 2 INDArrays
|
static INDArray |
Transforms.min(INDArray ndArray,
double k)
Maximum function with a scalar
|
static INDArray |
Transforms.min(INDArray ndArray,
double k,
boolean dup)
Minimum function with a scalar
|
static INDArray |
Transforms.min(INDArray first,
INDArray second)
Element wise minimum function between 2 INDArrays
|
static INDArray |
Transforms.min(INDArray first,
INDArray second,
boolean dup)
Element wise minimum function between 2 INDArrays
|
static INDArray |
Transforms.mpow(INDArray in,
int n,
boolean dup)
Raises a square matrix to a power n, which can be positive, negative, or zero.
|
static INDArray |
Transforms.neg(INDArray ndArray)
Returns the negative of an ndarray
|
static INDArray |
Transforms.neg(INDArray ndArray,
boolean dup)
Negative
|
static INDArray |
Transforms.normalizeZeroMeanAndUnitVariance(INDArray toNormalize)
Normalize data to zero mean and unit variance
substract by the mean and divide by the standard deviation
|
static INDArray |
Transforms.not(INDArray x) |
static INDArray |
Transforms.or(INDArray x,
INDArray y) |
static INDArray |
Transforms.pow(INDArray ndArray,
INDArray power)
Element-wise power function - x^y, performed element-wise.
|
static INDArray |
Transforms.pow(INDArray ndArray,
INDArray power,
boolean dup)
Element-wise power function - x^y, performed element-wise
|
static INDArray |
Transforms.pow(INDArray ndArray,
Number power)
Pow function
|
static INDArray |
Transforms.pow(INDArray ndArray,
Number power,
boolean dup)
Pow function
|
static INDArray |
Transforms.relu(INDArray arr) |
static INDArray |
Transforms.relu(INDArray in,
boolean copy) |
static INDArray |
Transforms.relu6(INDArray arr) |
static INDArray |
Transforms.relu6(INDArray in,
boolean copy) |
static INDArray |
Transforms.reverse(INDArray x,
boolean dup) |
static INDArray |
Transforms.round(INDArray ndArray)
Rounding function
|
static INDArray |
Transforms.round(INDArray ndArray,
boolean dup)
Rounding function
|
static INDArray |
Transforms.sigmoid(INDArray ndArray)
Sigmoid function
|
static INDArray |
Transforms.sigmoid(INDArray ndArray,
boolean dup)
Sigmoid function
|
static INDArray |
Transforms.sigmoidDerivative(INDArray ndArray)
Sigmoid function
|
static INDArray |
Transforms.sigmoidDerivative(INDArray ndArray,
boolean dup)
Sigmoid function
|
static INDArray |
Transforms.sign(INDArray toSign)
Signum function of this ndarray
|
static INDArray |
Transforms.sign(INDArray toSign,
boolean dup)
Signum function of this ndarray
|
static INDArray |
Transforms.sin(INDArray in)
Sin function
|
static INDArray |
Transforms.sin(INDArray in,
boolean copy)
Sin function
|
static INDArray |
Transforms.sinh(INDArray in)
Sinh function
|
static INDArray |
Transforms.sinh(INDArray in,
boolean copy)
Sinh function
|
static INDArray |
Transforms.softmax(INDArray arr) |
static INDArray |
Transforms.softmax(INDArray in,
boolean copy) |
static INDArray |
Transforms.softPlus(INDArray arr) |
static INDArray |
Transforms.softPlus(INDArray in,
boolean copy) |
static INDArray |
Transforms.softsign(INDArray arr) |
static INDArray |
Transforms.softsign(INDArray in,
boolean copy) |
static INDArray |
Transforms.softsignDerivative(INDArray arr) |
static INDArray |
Transforms.softsignDerivative(INDArray in,
boolean copy) |
static INDArray |
Transforms.sqrt(INDArray ndArray)
Sqrt function
|
static INDArray |
Transforms.sqrt(INDArray ndArray,
boolean dup)
Sqrt function
|
static INDArray |
Transforms.stabilize(INDArray ndArray,
double k) |
static INDArray |
Transforms.stabilize(INDArray ndArray,
double k,
boolean dup)
Stabilize to be within a range of k
|
static INDArray |
Transforms.step(INDArray arr) |
static INDArray |
Transforms.step(INDArray in,
boolean copy) |
static INDArray |
Transforms.tan(INDArray ndArray)
Element-wise tan function.
|
static INDArray |
Transforms.tan(INDArray ndArray,
boolean dup)
Element-wise tan function.
|
static INDArray |
Transforms.tanh(INDArray ndArray)
Tanh function
|
static INDArray |
Transforms.tanh(INDArray ndArray,
boolean dup)
Tanh function
|
static INDArray |
Transforms.timesOneMinus(INDArray in,
boolean copy)
out = in * (1-in)
|
static INDArray |
Transforms.unitVec(INDArray toScale)
Scale by 1 / norm2 of the matrix
|
static INDArray |
Transforms.xor(INDArray x,
INDArray y) |
| Modifier and Type | Method and Description |
|---|---|
void |
OpProfiler.processBlasCall(boolean isGemm,
INDArray... operands) |
OpProfiler.PenaltyCause[] |
OpProfiler.processOperands(INDArray... operands)
This method checks for something somewhere
|
OpProfiler.PenaltyCause[] |
OpProfiler.processOperands(INDArray x,
INDArray y) |
OpProfiler.PenaltyCause[] |
OpProfiler.processOperands(INDArray x,
INDArray y,
INDArray z) |
String |
OpProfiler.processOrders(INDArray... operands) |
| Modifier and Type | Method and Description |
|---|---|
String |
NDArrayStrings.format(INDArray arr) |
String |
NDArrayStrings.format(INDArray arr,
boolean summarize)
Format the given ndarray as a string
|
| Modifier and Type | Field and Description |
|---|---|
protected INDArray |
DeviceLocal.delayedArray |
| Modifier and Type | Method and Description |
|---|---|
INDArray |
DeviceLocalNDArray.get()
This method returns object local to current deviceId
|
static INDArray |
NDArrayUtil.toNDArray(int[] nums) |
static INDArray |
NDArrayUtil.toNDArray(int[][] nums) |
static INDArray |
NDArrayUtil.toNDArray(long[] nums) |
static INDArray |
FeatureUtil.toOutcomeMatrix(int[] index,
long numOutcomes)
Creates an out come vector from the specified inputs
|
static INDArray |
FeatureUtil.toOutcomeVector(long index,
long numOutcomes)
Creates an out come vector from the specified inputs
|
| Modifier and Type | Method and Description |
|---|---|
Boolean |
ND4JTestUtils.EqualsFn.apply(INDArray i1,
INDArray i2) |
Boolean |
ND4JTestUtils.EqualsWithEpsFn.apply(INDArray i1,
INDArray i2) |
static void |
LinAlgExceptions.assertColumns(INDArray n,
INDArray n2) |
static void |
LinAlgExceptions.assertMatrix(INDArray... arr) |
static void |
LinAlgExceptions.assertMatrix(INDArray arr) |
static void |
LinAlgExceptions.assertMultiplies(INDArray nd1,
INDArray nd2)
Asserts matrix multiply rules (columns of left == rows of right or rows of left == columns of right)
|
static void |
LinAlgExceptions.assertRows(INDArray n,
INDArray n2) |
static void |
LinAlgExceptions.assertSameLength(INDArray x,
INDArray z)
Asserts both arrays be the same length
|
static void |
LinAlgExceptions.assertSameLength(INDArray x,
INDArray y,
INDArray z) |
static void |
LinAlgExceptions.assertSameShape(INDArray n,
INDArray n2) |
static void |
LinAlgExceptions.assertSameShape(INDArray x,
INDArray y,
INDArray z) |
static void |
LinAlgExceptions.assertValidNum(INDArray n) |
static void |
LinAlgExceptions.assertVector(INDArray... arr) |
static void |
LinAlgExceptions.assertVector(INDArray arr) |
void |
DeviceLocalNDArray.broadcast(INDArray array)
This method duplicates array, and stores it to all devices
PLEASE NOTE: this method is NOT atomic, so you must be sure no other threads are using this instance during the update
|
static long |
NDArrayMath.lengthPerSlice(INDArray arr)
Return the length of a slice
|
static long |
NDArrayMath.lengthPerSlice(INDArray arr,
int... dimension)
The number of elements in a slice
along a set of dimensions
|
static int |
NDArrayMath.mapIndexOntoTensor(int index,
INDArray arr,
int... rank)
This maps an index of a vector
on to a vector in the matrix that can be used
for indexing in to a tensor
|
static long |
NDArrayMath.mapIndexOntoVector(int index,
INDArray arr)
This maps an index of a vector
on to a vector in the matrix that can be used
for indexing in to a tensor
|
static long |
NDArrayMath.matricesPerSlice(INDArray arr)
The number of vectors
in each slice of an ndarray.
|
static void |
FeatureUtil.normalizeMatrix(INDArray toNormalize) |
static long |
NDArrayMath.numVectors(INDArray arr)
Return the number of vectors for an array
the number of vectors for an array
|
static long |
NDArrayMath.offsetForSlice(INDArray arr,
int slice)
Compute the offset for a given slice
|
static void |
FeatureUtil.scaleByMax(INDArray toScale)
Divides each row by its max
|
static void |
FeatureUtil.scaleMinMax(double min,
double max,
INDArray toScale)
Scales the ndarray columns
to the given min/max values
|
void |
DataSetUtils.showINDArray(int mtLv,
String itemCode,
INDArray INDA,
int digits,
int r_End_I,
int c_End_I)
showINDArray
public void showINDArray( int mtLv, String itemCode, INDArray INDA, int digits, int r_End_I, int c_End_I ) Shows content of INDArray. |
void |
DataSetUtils.showINDArray(int mtLv,
String itemCode,
INDArray INDA,
int digits,
int r_End_I,
int c_End_I,
boolean turned)
showINDArray
public void showINDArray( int mtLv, String itemCode, INDArray INDA, int digits, int r_End_I, int c_End_I, boolean turned ) Shows content of INDArray. |
static long |
NDArrayMath.sliceOffsetForTensor(int index,
INDArray arr,
int[] tensorShape)
calculates the offset for a tensor
|
static long |
NDArrayMath.sliceOffsetForTensor(int index,
INDArray arr,
long[] tensorShape) |
static long |
NDArrayMath.tensorsPerSlice(INDArray arr,
int[] tensorShape)
Computes the tensors per slice
given a tensor shape and array
|
static int[] |
NDArrayUtil.toInts(INDArray n) |
static long[] |
NDArrayUtil.toLongs(INDArray n) |
void |
DeviceLocalNDArray.update(INDArray array)
This method updates
PLEASE NOTE: this method is NOT atomic, so you must be sure no other threads are using this instance during the update
|
static long |
NDArrayMath.vectorsPerSlice(INDArray arr)
The number of vectors
in each slice of an ndarray.
|
static long |
NDArrayMath.vectorsPerSlice(INDArray arr,
int... rank)
The number of vectors
in each slice of an ndarray.
|
| Modifier and Type | Method and Description |
|---|---|
static ND4JTestUtils.ComparisonResult |
ND4JTestUtils.validateSerializedArrays(File dir1,
File dir2,
boolean recursive,
BiFunction<INDArray,INDArray,Boolean> evalFn)
Scan the specified directories for matching files (i.e., same path relative to their respective root directories)
and compare the contents using a provided function.
|
static ND4JTestUtils.ComparisonResult |
ND4JTestUtils.validateSerializedArrays(File dir1,
File dir2,
boolean recursive,
BiFunction<INDArray,INDArray,Boolean> evalFn)
Scan the specified directories for matching files (i.e., same path relative to their respective root directories)
and compare the contents using a provided function.
|
| Constructor and Description |
|---|
DeviceLocalNDArray(INDArray array) |
DeviceLocalNDArray(INDArray array,
boolean delayedMode) |
| Modifier and Type | Method and Description |
|---|---|
INDArray |
WorkspaceMgr.castTo(T arrayType,
DataType dataType,
INDArray toCast,
boolean dupIfCorrectType)
Cast the specified array to the specified datatype.
|
INDArray |
BaseWorkspaceMgr.castTo(T arrayType,
DataType dataType,
INDArray toCast,
boolean dupIfCorrectType) |
INDArray |
WorkspaceMgr.create(T arrayType,
DataType dataType,
long... shape)
Create an array in the specified array type's workspace (or detached if none is specified).
|
INDArray |
BaseWorkspaceMgr.create(T arrayType,
DataType dataType,
long... shape) |
INDArray |
WorkspaceMgr.create(T arrayType,
DataType dataType,
long[] shape,
char ordering)
Create an array in the specified array type's workspace (or detached if none is specified).
|
INDArray |
BaseWorkspaceMgr.create(T arrayType,
DataType dataType,
long[] shape,
char order) |
INDArray |
WorkspaceMgr.createUninitialized(T arrayType,
DataType dataType,
long... shape)
Create an uninitialized array in the specified array type's workspace (or detached if none is specified).
|
INDArray |
BaseWorkspaceMgr.createUninitialized(T arrayType,
DataType dataType,
long... shape) |
INDArray |
WorkspaceMgr.createUninitialized(T arrayType,
DataType dataType,
long[] shape,
char order)
Create an uninitialized array in the specified array type's workspace (or detached if none is specified).
|
INDArray |
BaseWorkspaceMgr.createUninitialized(T arrayType,
DataType dataType,
long[] shape,
char order) |
INDArray |
WorkspaceMgr.dup(T arrayType,
INDArray toDup)
Duplicate the array, where the array is put into the specified array type's workspace (if applicable)
|
INDArray |
BaseWorkspaceMgr.dup(T arrayType,
INDArray toDup) |
INDArray |
WorkspaceMgr.dup(T arrayType,
INDArray toDup,
char order)
Duplicate the array, where the array is put into the specified array type's workspace (if applicable)
|
INDArray |
BaseWorkspaceMgr.dup(T arrayType,
INDArray toDup,
char order) |
INDArray |
WorkspaceMgr.leverageTo(T toWorkspace,
INDArray array)
Leverage the array to the specified array type's workspace (or detach if required).
|
INDArray |
BaseWorkspaceMgr.leverageTo(T arrayType,
INDArray array) |
INDArray |
WorkspaceMgr.validateArrayLocation(T arrayType,
INDArray array,
boolean migrateIfInvalid,
boolean exceptionIfDetached)
Validate that the specified array type is actually in the workspace it's supposed to be in
|
INDArray |
BaseWorkspaceMgr.validateArrayLocation(T arrayType,
INDArray array,
boolean migrateIfInvalid,
boolean exceptionIfDetached) |
| Modifier and Type | Method and Description |
|---|---|
static void |
WorkspaceUtils.assertValidArray(INDArray array,
String msg)
Assert that the specified array is valid, in terms of workspaces: i.e., if it is attached (and not in a circular
workspace), assert that the workspace is open, and that the data is not from an old generation.
|
INDArray |
WorkspaceMgr.castTo(T arrayType,
DataType dataType,
INDArray toCast,
boolean dupIfCorrectType)
Cast the specified array to the specified datatype.
|
INDArray |
BaseWorkspaceMgr.castTo(T arrayType,
DataType dataType,
INDArray toCast,
boolean dupIfCorrectType) |
INDArray |
WorkspaceMgr.dup(T arrayType,
INDArray toDup)
Duplicate the array, where the array is put into the specified array type's workspace (if applicable)
|
INDArray |
BaseWorkspaceMgr.dup(T arrayType,
INDArray toDup) |
INDArray |
WorkspaceMgr.dup(T arrayType,
INDArray toDup,
char order)
Duplicate the array, where the array is put into the specified array type's workspace (if applicable)
|
INDArray |
BaseWorkspaceMgr.dup(T arrayType,
INDArray toDup,
char order) |
INDArray |
WorkspaceMgr.leverageTo(T toWorkspace,
INDArray array)
Leverage the array to the specified array type's workspace (or detach if required).
|
INDArray |
BaseWorkspaceMgr.leverageTo(T arrayType,
INDArray array) |
INDArray |
WorkspaceMgr.validateArrayLocation(T arrayType,
INDArray array,
boolean migrateIfInvalid,
boolean exceptionIfDetached)
Validate that the specified array type is actually in the workspace it's supposed to be in
|
INDArray |
BaseWorkspaceMgr.validateArrayLocation(T arrayType,
INDArray array,
boolean migrateIfInvalid,
boolean exceptionIfDetached) |
| Modifier and Type | Field and Description |
|---|---|
protected INDArray |
BaseNDArrayList.container |
| Modifier and Type | Method and Description |
|---|---|
INDArray |
NDArrayList.array()
Get a view of the underlying array
relative to the size of the actual array.
|
INDArray |
BaseNDArrayList.array()
Get a view of the underlying array
relative to the size of the actual array.
|
| Constructor and Description |
|---|
NDArrayList(INDArray container)
Specify the underlying ndarray for this list.
|
NDArrayList(INDArray container,
int size)
Specify the underlying ndarray for this list.
|
| Modifier and Type | Method and Description |
|---|---|
INDArray |
BaseNativeNDArrayFactory.createFromNpyFile(File file)
Create from a given numpy file.
|
INDArray |
BaseNativeNDArrayFactory.createFromNpyHeaderPointer(org.bytedeco.javacpp.Pointer pointer) |
INDArray |
BaseNativeNDArrayFactory.createFromNpyPointer(org.bytedeco.javacpp.Pointer pointer)
Create from an in memory numpy pointer.
|
| Modifier and Type | Method and Description |
|---|---|
Map<String,INDArray> |
BaseNativeNDArrayFactory._createFromNpzFile(File file) |
Map<String,INDArray> |
BaseNativeNDArrayFactory.createFromNpzFile(File file) |
| Modifier and Type | Method and Description |
|---|---|
org.bytedeco.javacpp.Pointer |
BaseNativeNDArrayFactory.convertToNumpy(INDArray array) |
| Modifier and Type | Method and Description |
|---|---|
INDArray |
ParameterServerSubscriber.getMasterArray()
Get the master ndarray from the
internal
NDArrayHolder |
| Modifier and Type | Method and Description |
|---|---|
void |
PublishingListener.onNDArray(INDArray arr)
Setup an ndarray
|
void |
ParameterServerListener.onNDArray(INDArray arr)
Setup an ndarray
|
void |
PublishingListener.onNDArrayPartial(INDArray arr,
long idx,
int... dimensions)
Used for partial updates using tensor along
dimension
|
void |
ParameterServerListener.onNDArrayPartial(INDArray arr,
long idx,
int... dimensions)
Used for partial updates using tensor along
dimension
|
| Modifier and Type | Method and Description |
|---|---|
INDArray |
ParameterServerClient.getArray()
Get an ndarray from the
designated ndarray retrieve url.
|
| Modifier and Type | Method and Description |
|---|---|
void |
ParameterServerClient.onNDArray(INDArray arr)
Setup an ndarray
|
void |
ParameterServerClient.onNDArrayPartial(INDArray arr,
long idx,
int... dimensions)
Used for partial updates using tensor along
dimension
|
void |
ParameterServerClient.pushNDArray(INDArray arr)
Push an ndarray to the specified
ndarray send url in the form of:
host;port:stream
where stream is the stream for connecting
to a listening aeron server
|
| Modifier and Type | Method and Description |
|---|---|
protected INDArray |
VoidParameterServer.getExpTable()
Deprecated.
|
protected INDArray |
VoidParameterServer.getNegTable()
Deprecated.
|
protected INDArray |
VoidParameterServer.getSyn0()
Deprecated.
|
protected INDArray |
VoidParameterServer.getSyn1()
Deprecated.
|
protected INDArray |
VoidParameterServer.getSyn1Neg()
Deprecated.
|
INDArray |
VoidParameterServer.getVector(int rowIdx)
Deprecated.
|
INDArray |
VoidParameterServer.getVector(Integer key,
int rowIdx)
Deprecated.
This method returns INDArray matching requested storageId value
PLEASE NOTE: This method IS blocking
|
| Modifier and Type | Method and Description |
|---|---|
INDArray |
Storage.getArray(Integer key)
Deprecated.
|
| Modifier and Type | Method and Description |
|---|---|
void |
Storage.setArray(Integer key,
INDArray array)
Deprecated.
|
| Modifier and Type | Method and Description |
|---|---|
INDArray |
BaseStorage.getArray(Integer key)
Deprecated.
|
| Modifier and Type | Method and Description |
|---|---|
void |
BaseStorage.setArray(Integer key,
INDArray array)
Deprecated.
|
| Modifier and Type | Method and Description |
|---|---|
INDArray |
VoidAggregation.getAccumulatedResult()
Deprecated.
|
INDArray |
VoidAggregation.getPayload()
Deprecated.
|
INDArray |
MeaningfulMessage.getPayload()
Deprecated.
|
| Modifier and Type | Field and Description |
|---|---|
protected INDArray |
BaseAggregation.payload
Deprecated.
|
| Modifier and Type | Field and Description |
|---|---|
protected Map<Short,INDArray> |
BaseAggregation.chunks
Deprecated.
|
| Modifier and Type | Method and Description |
|---|---|
INDArray |
DotAggregation.getAccumulatedResult()
Deprecated.
|
INDArray |
BaseAggregation.getAccumulatedResult()
Deprecated.
|
| Modifier and Type | Method and Description |
|---|---|
protected void |
BaseAggregation.addToChunks(INDArray array)
Deprecated.
|
| Constructor and Description |
|---|
DotAggregation(long taskId,
short aggregationWidth,
short shardIndex,
INDArray scalar)
Deprecated.
|
VectorAggregation(long taskId,
short aggregationWidth,
short shardIndex,
INDArray array)
Deprecated.
|
| Modifier and Type | Field and Description |
|---|---|
protected INDArray |
BaseCompleteMessage.payload
Deprecated.
|
| Constructor and Description |
|---|
VectorCompleteMessage(long taskId,
INDArray vector)
Deprecated.
|
| Modifier and Type | Method and Description |
|---|---|
protected INDArray |
DistributedInitializationMessage.initExpTable(int tableWidth)
Deprecated.
|
| Constructor and Description |
|---|
DistributedAssignMessage(Integer key,
INDArray payload)
Deprecated.
|
DistributedSolidMessage(Integer key,
INDArray array,
boolean overwrite)
Deprecated.
|
| Modifier and Type | Field and Description |
|---|---|
protected INDArray |
AssignRequestMessage.payload
Deprecated.
|
| Constructor and Description |
|---|
AssignRequestMessage(Integer key,
INDArray array)
Deprecated.
|
| Modifier and Type | Field and Description |
|---|---|
protected List<org.reactivestreams.Subscriber<INDArray>> |
ModelParameterServer.modelParamsSubsribers |
protected List<org.reactivestreams.Subscriber<INDArray>> |
ModelParameterServer.updaterParamsSubscribers |
protected BlockingQueue<INDArray> |
ModelParameterServer.updatesBacklog |
| Modifier and Type | Method and Description |
|---|---|
Collection<INDArray> |
ModelParameterServer.getUpdates()
This method returns updates received from network
|
| Modifier and Type | Method and Description |
|---|---|
void |
ModelParameterServer.sendUpdate(INDArray array)
This method sends gradient updates to the cluster
|
void |
ModelParameterServer.sendUpdate(INDArray array,
int iteration,
int epoch) |
| Modifier and Type | Method and Description |
|---|---|
void |
ModelParameterServer.addModelParamsSubscriber(org.reactivestreams.Subscriber<INDArray> s)
This method adds subcriber that will be called upon model params receival
|
void |
ModelParameterServer.addUpdaterParamsSubscriber(org.reactivestreams.Subscriber<INDArray> s)
This method adds subcriber that will be called upon updater params receival
|
| Modifier and Type | Method and Description |
|---|---|
INDArray |
INDArrayMessage.getPayload() |
| Constructor and Description |
|---|
GradientsUpdateMessage(String messageId,
INDArray payload) |
| Modifier and Type | Field and Description |
|---|---|
protected INDArray |
BaseINDArrayMessage.payload |
| Constructor and Description |
|---|
BaseINDArrayMessage(String messageId,
INDArray payload) |
| Constructor and Description |
|---|
ModelParametersMessage(String messageId,
INDArray payload) |
UpdaterParametersMessage(String messageId,
INDArray payload) |
| Modifier and Type | Method and Description |
|---|---|
INDArray |
UpdatesHandler.getParametersArray()
This method returns parameters array maintained by this handler
|
INDArray |
UpdaterParametersProvider.getUpdaterParameters()
This method provides *safe* copy of updater parameters state
|
| Modifier and Type | Method and Description |
|---|---|
void |
TimeDelayedParameterUpdater.partialUpdate(INDArray arr,
INDArray result,
long idx,
int... dimensions)
Updates result
based on arr along a particular
INDArray#tensorAlongDimension(int, int...) |
void |
SynchronousParameterUpdater.partialUpdate(INDArray arr,
INDArray result,
long idx,
int... dimensions)
Updates result
based on arr along a particular
INDArray#tensorAlongDimension(int, int...) |
void |
SoftSyncParameterUpdater.partialUpdate(INDArray arr,
INDArray result,
long idx,
int... dimensions)
Updates result
based on arr along a particular
INDArray#tensorAlongDimension(int, int...) |
void |
ParameterServerUpdater.partialUpdate(INDArray arr,
INDArray result,
long idx,
int... dimensions)
Updates result
based on arr along a particular
INDArray#tensorAlongDimension(int, int...) |
void |
TimeDelayedParameterUpdater.update(INDArray arr,
INDArray result)
Updates result
based on arr
|
void |
SynchronousParameterUpdater.update(INDArray arr,
INDArray result)
Updates result
based on arr
|
void |
SoftSyncParameterUpdater.update(INDArray arr,
INDArray result)
Updates result
based on arr
|
void |
ParameterServerUpdater.update(INDArray arr,
INDArray result)
Updates result
based on arr
|
| Modifier and Type | Method and Description |
|---|---|
INDArray |
NativeRandom.nextDouble(char order,
int[] shape) |
INDArray |
NativeRandom.nextDouble(char order,
long[] shape) |
INDArray |
NativeRandom.nextDouble(int[] shape) |
INDArray |
NativeRandom.nextDouble(long[] shape) |
INDArray |
NativeRandom.nextFloat(char order,
int[] shape) |
INDArray |
NativeRandom.nextFloat(char order,
long[] shape) |
INDArray |
NativeRandom.nextFloat(int[] shape) |
INDArray |
NativeRandom.nextFloat(long[] shape) |
INDArray |
NativeRandom.nextGaussian(char order,
int[] shape) |
INDArray |
NativeRandom.nextGaussian(char order,
long[] shape) |
INDArray |
NativeRandom.nextGaussian(int[] shape) |
INDArray |
NativeRandom.nextGaussian(long[] shape) |
INDArray |
NativeRandom.nextInt(int[] shape) |
INDArray |
NativeRandom.nextInt(int n,
int[] shape) |
INDArray |
NativeRandom.nextInt(int n,
long[] shape) |
INDArray |
NativeRandom.nextInt(long[] shape) |
| Modifier and Type | Method and Description |
|---|---|
static INDArray |
Nd4jBase64.fromBase64(String base64)
Create an ndarray from a base 64
representation
|
| Modifier and Type | Method and Description |
|---|---|
static String |
Nd4jBase64.base64String(INDArray arr)
Returns an ndarray
as base 64
|
| Modifier and Type | Method and Description |
|---|---|
static INDArray |
BinarySerde.readFromDisk(File readFrom)
Read an ndarray from disk
|
static INDArray |
BinarySerde.toArray(ByteBuffer buffer)
Create an ndarray
from the unsafe buffer
|
static INDArray |
BinarySerde.toArray(ByteBuffer buffer,
int offset)
Create an ndarray
from the unsafe buffer
|
| Modifier and Type | Method and Description |
|---|---|
protected static Pair<INDArray,ByteBuffer> |
BinarySerde.toArrayAndByteBuffer(ByteBuffer buffer,
int offset)
Create an ndarray and existing bytebuffer
|
| Modifier and Type | Method and Description |
|---|---|
static int |
BinarySerde.byteBufferSizeFor(INDArray arr)
Returns the byte buffer size for the given
ndarray.
|
static void |
BinarySerde.doByteBufferPutCompressed(INDArray arr,
ByteBuffer allocated,
boolean rewind)
Setup the given byte buffer
for serialization (note that this is for compressed INDArrays)
4 bytes for rank
4 bytes for data opType
shape information
codec information
data opType
|
static void |
BinarySerde.doByteBufferPutUnCompressed(INDArray arr,
ByteBuffer allocated,
boolean rewind)
Setup the given byte buffer
for serialization (note that this is for uncompressed INDArrays)
4 bytes int for rank
4 bytes for data opType
shape buffer
data buffer
|
static ByteBuffer |
BinarySerde.toByteBuffer(INDArray arr)
Convert an ndarray to an unsafe buffer
for use by aeron
|
static void |
BinarySerde.writeArrayToDisk(INDArray arr,
File toWrite)
Write an ndarray to disk in
binary format
|
static void |
BinarySerde.writeArrayToOutputStream(INDArray arr,
OutputStream outputStream)
Write an array to an output stream.
|
| Modifier and Type | Method and Description |
|---|---|
static INDArray |
GsonDeserializationUtils.deserializeRawJson(String serializedRawArray)
Deserialize an ndarray
form json
|
| Modifier and Type | Method and Description |
|---|---|
INDArray |
NDArrayTextDeSerializer.deserialize(org.nd4j.shade.jackson.core.JsonParser jp,
org.nd4j.shade.jackson.databind.DeserializationContext deserializationContext) |
INDArray |
NDArrayDeSerializer.deserialize(org.nd4j.shade.jackson.core.JsonParser jp,
org.nd4j.shade.jackson.databind.DeserializationContext deserializationContext) |
| Modifier and Type | Method and Description |
|---|---|
void |
NDArrayTextSerializer.serialize(INDArray arr,
org.nd4j.shade.jackson.core.JsonGenerator jg,
org.nd4j.shade.jackson.databind.SerializerProvider serializerProvider) |
void |
NDArraySerializer.serialize(INDArray indArray,
org.nd4j.shade.jackson.core.JsonGenerator jsonGenerator,
org.nd4j.shade.jackson.databind.SerializerProvider serializerProvider) |
| Modifier and Type | Method and Description |
|---|---|
INDArray |
VectorDeSerializer.deserialize(org.nd4j.shade.jackson.core.JsonParser jp,
org.nd4j.shade.jackson.databind.DeserializationContext deserializationContext)
Deprecated.
|
| Modifier and Type | Method and Description |
|---|---|
void |
VectorSerializer.serialize(INDArray indArray,
org.nd4j.shade.jackson.core.JsonGenerator jsonGenerator,
org.nd4j.shade.jackson.databind.SerializerProvider serializerProvider)
Deprecated.
|
| Modifier and Type | Method and Description |
|---|---|
INDArray |
NDArrayDeSerializer.deserialize(com.fasterxml.jackson.core.JsonParser jp,
com.fasterxml.jackson.databind.DeserializationContext deserializationContext)
Deprecated.
|
| Modifier and Type | Method and Description |
|---|---|
void |
NDArraySerializer.serialize(INDArray indArray,
com.fasterxml.jackson.core.JsonGenerator jsonGenerator,
com.fasterxml.jackson.databind.SerializerProvider serializerProvider)
Deprecated.
|
| Modifier and Type | Method and Description |
|---|---|
INDArray |
NDArrayDeSerializer.deserialize(org.nd4j.shade.jackson.core.JsonParser jp,
org.nd4j.shade.jackson.databind.DeserializationContext deserializationContext)
Deprecated.
|
| Modifier and Type | Method and Description |
|---|---|
void |
NDArraySerializer.serialize(INDArray indArray,
org.nd4j.shade.jackson.core.JsonGenerator jsonGenerator,
org.nd4j.shade.jackson.databind.SerializerProvider serializerProvider)
Deprecated.
|
| Modifier and Type | Method and Description |
|---|---|
INDArray |
CompressedRamStorage.get(T key)
Get object from the storage, by key
|
| Modifier and Type | Method and Description |
|---|---|
void |
CompressedRamStorage.store(T key,
INDArray object)
Store object into storage
|
boolean |
CompressedRamStorage.storeIfAbsent(T key,
INDArray object)
Store object into storage, if it doesn't exist
|
| Modifier and Type | Method and Description |
|---|---|
INDArray |
TensorflowConversion.ndArrayFromTensor(org.bytedeco.tensorflow.TF_Tensor tensor)
Convert a
INDArray
to a TF_Tensor
using zero copy. |
| Modifier and Type | Method and Description |
|---|---|
static TensorDataType |
TensorDataType.fromNd4jType(INDArray array) |
org.bytedeco.tensorflow.TF_Tensor |
TensorflowConversion.tensorFromNDArray(INDArray ndArray)
Convert an
INDArray
to a TF_Tensor
with zero copy. |
| Modifier and Type | Method and Description |
|---|---|
Map<String,INDArray> |
GraphRunner.run(Map<String,INDArray> inputs)
Returns a map of the output names
to the ndarrays matching each output.
|
| Modifier and Type | Method and Description |
|---|---|
Map<String,INDArray> |
GraphRunner.run(Map<String,INDArray> inputs)
Returns a map of the output names
to the ndarrays matching each output.
|
| Modifier and Type | Method and Description |
|---|---|
INDArray |
WeightInitScheme.create(DataType dataType,
long... shape)
Create the array
|
INDArray |
BaseWeightInitScheme.create(DataType dataType,
long... shape) |
INDArray |
WeightInitScheme.create(long[] shape,
INDArray paramsView)
Create the array
|
INDArray |
BaseWeightInitScheme.create(long[] shape,
INDArray paramsView) |
abstract INDArray |
BaseWeightInitScheme.doCreate(DataType dataType,
long[] shape,
INDArray paramsView) |
protected INDArray |
BaseWeightInitScheme.handleParamsView(INDArray outputArray,
INDArray paramView) |
| Modifier and Type | Method and Description |
|---|---|
INDArray |
WeightInitScheme.create(long[] shape,
INDArray paramsView)
Create the array
|
INDArray |
BaseWeightInitScheme.create(long[] shape,
INDArray paramsView) |
abstract INDArray |
BaseWeightInitScheme.doCreate(DataType dataType,
long[] shape,
INDArray paramsView) |
protected INDArray |
BaseWeightInitScheme.handleParamsView(INDArray outputArray,
INDArray paramView) |
| Modifier and Type | Method and Description |
|---|---|
INDArray |
NDArraySupplierInitScheme.create(DataType dataType,
long[] shape) |
INDArray |
NDArraySupplierInitScheme.create(long[] shape,
INDArray paramsView) |
INDArray |
ZeroInitScheme.doCreate(DataType dataType,
long[] shape,
INDArray paramsView) |
INDArray |
XavierUniformInitScheme.doCreate(DataType dataType,
long[] shape,
INDArray paramsView) |
INDArray |
XavierInitScheme.doCreate(DataType dataType,
long[] shape,
INDArray paramsView) |
INDArray |
XavierFanInInitScheme.doCreate(DataType dataType,
long[] shape,
INDArray paramsView) |
INDArray |
VarScalingUniformFanAvgInitScheme.doCreate(DataType dataType,
long[] shape,
INDArray paramsView) |
INDArray |
VarScalingNormalUniformFanOutInitScheme.doCreate(DataType dataType,
long[] shape,
INDArray paramsView) |
INDArray |
VarScalingNormalUniformFanInInitScheme.doCreate(DataType dataType,
long[] shape,
INDArray paramsView) |
INDArray |
VarScalingNormalFanOutInitScheme.doCreate(DataType dataType,
long[] shape,
INDArray paramsView) |
INDArray |
VarScalingNormalFanInInitScheme.doCreate(DataType dataType,
long[] shape,
INDArray paramsView) |
INDArray |
VarScalingNormalFanAvgInitScheme.doCreate(DataType dataType,
long[] shape,
INDArray paramsView) |
INDArray |
UniformInitScheme.doCreate(DataType dataType,
long[] shape,
INDArray paramsView) |
INDArray |
SigmoidUniformInitScheme.doCreate(DataType dataType,
long[] shape,
INDArray paramsView) |
INDArray |
ReluUniformInitScheme.doCreate(DataType dataType,
long[] shape,
INDArray paramsView) |
INDArray |
ReluInitScheme.doCreate(DataType dataType,
long[] shape,
INDArray paramsView) |
INDArray |
OneInitScheme.doCreate(DataType dataType,
long[] shape,
INDArray paramsView) |
INDArray |
LecunUniformInitScheme.doCreate(DataType dataType,
long[] shape,
INDArray paramsView) |
INDArray |
IdentityInitScheme.doCreate(DataType dataType,
long[] shape,
INDArray paramsView) |
INDArray |
DistributionInitScheme.doCreate(DataType dataType,
long[] shape,
INDArray paramsView) |
INDArray |
ConstantInitScheme.doCreate(DataType dataType,
long[] shape,
INDArray paramsView) |
INDArray |
NDArraySupplierInitScheme.NDArraySupplier.getArr()
An array proxy method.
|
| Modifier and Type | Method and Description |
|---|---|
INDArray |
NDArraySupplierInitScheme.create(long[] shape,
INDArray paramsView) |
INDArray |
ZeroInitScheme.doCreate(DataType dataType,
long[] shape,
INDArray paramsView) |
INDArray |
XavierUniformInitScheme.doCreate(DataType dataType,
long[] shape,
INDArray paramsView) |
INDArray |
XavierInitScheme.doCreate(DataType dataType,
long[] shape,
INDArray paramsView) |
INDArray |
XavierFanInInitScheme.doCreate(DataType dataType,
long[] shape,
INDArray paramsView) |
INDArray |
VarScalingUniformFanAvgInitScheme.doCreate(DataType dataType,
long[] shape,
INDArray paramsView) |
INDArray |
VarScalingNormalUniformFanOutInitScheme.doCreate(DataType dataType,
long[] shape,
INDArray paramsView) |
INDArray |
VarScalingNormalUniformFanInInitScheme.doCreate(DataType dataType,
long[] shape,
INDArray paramsView) |
INDArray |
VarScalingNormalFanOutInitScheme.doCreate(DataType dataType,
long[] shape,
INDArray paramsView) |
INDArray |
VarScalingNormalFanInInitScheme.doCreate(DataType dataType,
long[] shape,
INDArray paramsView) |
INDArray |
VarScalingNormalFanAvgInitScheme.doCreate(DataType dataType,
long[] shape,
INDArray paramsView) |
INDArray |
UniformInitScheme.doCreate(DataType dataType,
long[] shape,
INDArray paramsView) |
INDArray |
SigmoidUniformInitScheme.doCreate(DataType dataType,
long[] shape,
INDArray paramsView) |
INDArray |
ReluUniformInitScheme.doCreate(DataType dataType,
long[] shape,
INDArray paramsView) |
INDArray |
ReluInitScheme.doCreate(DataType dataType,
long[] shape,
INDArray paramsView) |
INDArray |
OneInitScheme.doCreate(DataType dataType,
long[] shape,
INDArray paramsView) |
INDArray |
LecunUniformInitScheme.doCreate(DataType dataType,
long[] shape,
INDArray paramsView) |
INDArray |
IdentityInitScheme.doCreate(DataType dataType,
long[] shape,
INDArray paramsView) |
INDArray |
DistributionInitScheme.doCreate(DataType dataType,
long[] shape,
INDArray paramsView) |
INDArray |
ConstantInitScheme.doCreate(DataType dataType,
long[] shape,
INDArray paramsView) |
| Constructor and Description |
|---|
NDArraySupplierInitScheme(INDArray arr) |
Copyright © 2020. All rights reserved.